Stream流

说到Stream便容易想到I/O Stream，而实际上，谁规定“流”就一定是“IO流”呢？在Java 8中，得益于Lambda所带来的函数式编程，引入了一个全新的Stream概念，用于解决已有集合类库既有的弊端。
流模型的操作很丰富，这里介绍一些常用的API。这些方法可以被分成两种：
延迟方法：返回值类型仍然是 Stream 接口自身类型的方法，因此支持链式调用。（除了终结方法外，其余方
法均为延迟方法。）
终结方法：返回值类型不再是 Stream 接口自身类型的方法，因此不再支持类似 StringBuilder 那样的链式调用。本小节中，终结方法包括 count 和 forEach 方法。

题目：
现在有两个 ArrayList 集合存储队伍当中的多个成员姓名，要求使用传统的for循环（或增强for循环）依次进行以
下若干操作步骤：

1. 第一个队伍只要名字为3个字的成员姓名；存储到一个新集合中。
2. 第一个队伍筛选之后只要前3个人；存储到一个新集合中。
3. 第二个队伍只要姓张的成员姓名；存储到一个新集合中。
4. 第二个队伍筛选之后不要前2个人；存储到一个新集合中。
5. 将两个队伍合并为一个队伍；存储到一个新集合中。
6. 根据姓名创建 Person 对象；存储到一个新集合中。
7. 打印整个队伍的Person对象信息。
   两个队伍（集合）的代码如下：
   import java.util.stream.Stream;
   public class Demo11StreamSkip {
   public static void main(String[] args) {
   Stream original = Stream.of(“张无忌”, “张三丰”, “周芷若”);
   Stream result = original.skip(2);
   System.out.println(result.count()); // 1
   }
   }
   static Stream concat(Stream<? extends T> a, Stream<? extends T> b)
   import java.util.stream.Stream;
   public class Demo12StreamConcat {
   public static void main(String[] args) {
   Stream streamA = Stream.of(“张无忌”);
   Stream streamB = Stream.of(“张翠山”);
   Stream result = Stream.concat(streamA, streamB);
   }
   }
   import java.util.ArrayList;
   而 Person 类的代码为：
   import java.util.List;
   public class DemoArrayListNames {
   public static void main(String[] args) {
   //第一支队伍
   ArrayList one = new ArrayList<>();
   one.add(“迪丽热巴”);
   one.add(“宋远桥”);
   one.add(“苏星河”);
   one.add(“石破天”);
   one.add(“石中玉”);
   one.add(“老子”);
   one.add(“庄子”);
   one.add(“洪七公”);
   //第二支队伍
   ArrayList two = new ArrayList<>();
   two.add(“古力娜扎”);
   two.add(“张无忌”);
   two.add(“赵丽颖”);
   two.add(“张三丰”);
   two.add(“尼古拉斯赵四”);
   two.add(“张天爱”);
   two.add(“张二狗”);
   // …
   }
   }
   public class Person {
   private String name;
   public Person() {}
   public Person(String name) {
   this.name = name;
   }
   @Override
   public String toString() {
   return “Person{name=’” + name + “’}”;
   }
   public String getName() {
   return name;
   }
   public void setName(String name) {
   this.name = name;
   }
   解答
   既然使用传统的for循环写法，那么：
   }
   public class DemoArrayListNames {
   public static void main(String[] args) {
   List one = new ArrayList<>();
   // …
   List two = new ArrayList<>();
   // …
   // 第一个队伍只要名字为3个字的成员姓名；
   List oneA = new ArrayList<>();
   for (String name : one) {
   if (name.length() == 3) {
   oneA.add(name);
   }
   }
   // 第一个队伍筛选之后只要前3个人；
   List oneB = new ArrayList<>();
   for (int i = 0; i < 3; i++) {
   oneB.add(oneA.get(i));
   }
   // 第二个队伍只要姓张的成员姓名；
   List twoA = new ArrayList<>();
   for (String name : two) {
   if (name.startsWith(“张”)) {
   twoA.add(name);
   }
   }
   // 第二个队伍筛选之后不要前2个人；
   List twoB = new ArrayList<>();
   for (int i = 2; i < twoA.size(); i++) {
   twoB.add(twoA.get(i));
   }
   // 将两个队伍合并为一个队伍；
   List totalNames = new ArrayList<>();
   totalNames.addAll(oneB);
   totalNames.addAll(twoB);
   // 根据姓名创建Person对象；
   List totalPersonList = new ArrayList<>();
   for (String name : totalNames) {
   totalPersonList.add(new Person(name));
   }
   运行结果为：
   1.6 练习：集合元素处理（Stream方式）
   题目
   将上一题当中的传统for循环写法更换为Stream流式处理方式。两个集合的初始内容不变， Person 类的定义也不
   变。
   解答
   等效的Stream流式处理代码为：
   // 打印整个队伍的Person对象信息。
   for (Person person : totalPersonList) {
   System.out.println(person);
   }
   }
   }
   Person{name=‘宋远桥’}
   Person{name=‘苏星河’}
   Person{name=‘石破天’}
   Person{name=‘张天爱’}
   Person{name=‘张二狗’}
   import java.util.ArrayList;
   import java.util.List;
   import java.util.stream.Stream;
   public class DemoStreamNames {
   public static void main(String[] args) {
   List one = new ArrayList<>();
   // …
   List two = new ArrayList<>();
   // …
   // 第一个队伍只要名字为3个字的成员姓名；
   // 第一个队伍筛选之后只要前3个人；
   Stream streamOne = one.stream().filter(s ‐> s.length() == 3).limit(3);
   // 第二个队伍只要姓张的成员姓名；
   // 第二个队伍筛选之后不要前2个人；
   Stream streamTwo = two.stream().filter(s ‐> s.startsWith(“张”)).skip(2);
   // 将两个队伍合并为一个队伍；
   // 根据姓名创建Person对象；
   // 打印整个队伍的Person对象信息。
   Stream.concat(streamOne, streamTwo).map(Person::new).forEach(System.out::println);
   }
   运行效果完全一样：