一、概述

在Java 8中，得益于Lambda所带来的函数式编程，引入了一个全新的Stream概念，用于解决已有集合类库既有的弊端

传统集合的多步遍历代码（如Collection接口或Map接口等）

public class Demo10ForEach { public static void main(String[] args) {
List list = new ArrayList<>();
list.add(“张无忌”);
list.add(“周芷若”);
list.add(“赵敏”);
list.add(“张强”);
list.add(“张三丰”);
for (String name : list) {
System.out.println(name);
}
}
}

循环遍历的弊端*

因为要进行遍历。但循环是遍历的唯一方式吗？遍历是指每一个元素逐一进行处理，而并不是从第一个到最后一个顺次处理的循环

  1. public class Demo11NormalFilter {
  2.       public static void main(String[] args) {
  3.           List<String> list = new ArrayList<>();
  4.         list.add("张无忌");
  5.         list.add("周芷若");
  6.         list.add("赵敏");
  7.         list.add("张强");
  8.         list.add("张三丰");
  10.         List<String> zhangList = new ArrayList<>();
  11.         for (String name : list) {
  12.             if (name.startsWith("张")) {
  13.                   zhangList.add(name);
  14.             }
  15.         }
  17.         List<String> shortList = new ArrayList<>();
  18.         for (String name : zhangList) {
  19.             if (name.length() == 3) {
  20.                   shortList.add(name);
  21.             }
  22.         }
  24.         for (String name : shortList) {
  25.               System.out.println(name);
  26.         }
  27.     }
  28. }

Stream的更优写法

  1. public class Demo12StreamFilter {
  2.     public static void main(String[] args) {
  3.         List<String> list = new ArrayList<>();
  4.         list.add("张无忌");
  5.         list.add("周芷若");
  6.         list.add("赵敏");
  7.         list.add("张强");
  8.         list.add("张三丰");
  10.         list.stream()
  11.               .filter(s -> s.startsWith("张"))
  12.             .filter(s -> s.length() == 3)
  13.             .forEach(s -> System.out.println(s));
  14.     }
  15. }

思想：获取流、过滤姓张、过滤长度为3、逐一打印

二、流式思想概述

注意：请暂时忘记对传统IO流的固有印象！

流式思想类似于工厂车间的“生产流水线”。

image.png

这里的filter、map、skip都是在对函数模型进行操作，集合元素并没有真正被处理。只有当终结方法count执行的时候，整个模型才会按照指定策略执行操作。而这得益于Lambda的延迟执行特性。

获取流方式

  • 所有的Collection集合都可以通过stream默认方法获取流；

  • Stream接口的静态方法of可以获取数组对应的流。

    1.根据Collection获取流

    1. import java.util.*;
    2. import java.util.stream.Stream;
    3. /*
    4.   获取Stream流的方式
    6.   1.Collection中 方法
    7.       Stream stream()
    8.   2.Stream接口 中静态方法
    9.       of(T...t) 向Stream中添加多个数据
    10. */
    11. public class Demo13GetStream {
    12.   public static void main(String[] args) {
    13.       List<String> list = new ArrayList<>();
    14.       // ...
    15.       Stream<String> stream1 = list.stream();
    17.       Set<String> set = new HashSet<>();
    18.       // ...
    19.       Stream<String> stream2 = set.stream();
    20.   }
    21. }

    2.根据数组获取流

    由于数组对象不可能添加默认方法，所以Stream接口中提供了静态方法of

    1. public class Demo14GetStream {
    2.   public static void main(String[] args) {
    3.       String[] array = { "张无忌", "张翠山", "张三丰", "张一元" };
    4.       Stream<String> stream = Stream.of(array);
    5.   }
    6. }

    of方法的参数其实是一个可变参数，所以支持数组。

    常用方法

  • 终结方法：返回值类型不再是Stream接口自身类型的方法，因此不再支持类似StringBuilder那样的链式调用。本小节中，终结方法包括count和forEach方法。

  • 非终结方法：返回值类型仍然是Stream接口自身类型的方法，因此支持链式调用。（除了终结方法外，其余方法均为非终结方法。）

    forEach : 逐一处理

    void forEach(Consumer<? super T> action); 参数：

    1. Consumer属于消费函数式接口，我们在使用void forEach(Consumer<? super T> action);方法的时候可以传递lambda,完成Consumer接口中的 void accept(T t);

该方法接收一个Consumer接口函数，会将每一个流元素交给该函数进行处理。例如：

  1. import java.util.stream.Stream;
  3. public class Demo15StreamForEach {
  4.     public static void main(String[] args) {
  5.         Stream<String> stream =  Stream.of("大娃","二娃","三娃","四娃","五娃","六娃","七娃","爷爷","蛇精","蝎子精");
  6.         //Stream<String> stream = Stream.of("张无忌", "张三丰", "周芷若");
  7.         stream.forEach((String str)->{System.out.println(str);});
  8.     }
  9. }

filter：过滤

Stream filter(Predicate<? super T> predicate); 参数： Predicate 表示判断函数式接口，可以使用lambda，我们在使用filter(Predicate<? super T> predicate);方法的时候可以传递lambda完成Predicate 接口中的抽象方法 boolean test(T t); 如果，满足条件，方法test(T t)返回true，那么filter(Predicate<? super T> predicate);就会将满足条件的数据放到流水线中

该接口接收一个Predicate函数式接口参数（可以是一个Lambda）作为筛选条件。

  1. public class Demo16StreamFilter {
  2.     public static void main(String[] args) {
  3.         Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若");
  4.         Stream<String> result = original.filter((String s) -> {return s.startsWith("张");});
  5.     }
  6. }

count：统计个数

正如旧集合Collection当中的size方法一样，流提供count方法来数一数其中的元素个数：

long count();

  1. public class Demo17StreamCount {
  2.     public static void main(String[] args) {
  3.         Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若");
  4.         Stream<String> result = original.filter(s -> s.startsWith("张"));
  5.         System.out.println(result.count()); // 2
  6.     }
  7. }

limit：取用前几个

limit方法可以对流进行截取，只取用前n个。方法签名：

Stream limit(long maxSize):获取Stream流对象中的前n个元素,返回一个新的Stream流对象

  1. import java.util.stream.Stream;
  3. public class Demo18StreamLimit {
  4.     public static void main(String[] args) {
  5.         Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若");
  6.         Stream<String> result = original.limit(2);
  7.         System.out.println(result.count()); // 2
  8.     }
  9. }

skip：跳过前几个

Stream skip(long n): 跳过Stream流对象中的前n个元素,返回一个新的Stream流对象

  1. import java.util.stream.Stream;
  3. public class Demo19StreamSkip {
  4.     public static void main(String[] args) {
  5.         Stream<String> original = Stream.of("张无忌", "张三丰", "周芷若");
  6.         Stream<String> result = original.skip(2);
  7.         System.out.println(result.count()); // 1
  8.     }
  9. }

映射：map

需要将流中的元素映射到另一个流中，可以使用map方法

Stream map(Function<? super T, ? extends R> mapper); 属于延迟方法

  1. public class StreamMapDemo {
  2.     public static void main(String[] args) {
  3.         //创建老流对象存储String类型
  4.         Stream<String> strStream = Stream.of("123", "345", "567");
  5.         //使用map方法将老流转换为新流
  6.         //<R> Stream<R> map(Function<? super T, ? extends R> mapper);
  7.         //由于map方法的参数需要Function接口，Function只有一个抽象方法R apply(T t);属于函数式接口
  8.         //可以使用lambda
  9.         /*Stream<Integer> integerStream = strStream.map((s) -> {
  10.             return Integer.parseInt(s);
  11.         });*/
  12.          Stream<Integer> integerStream = strStream.map(s->Integer.parseInt(s));
  14.         //取出新流中的数据
  15.         integerStream.forEach(name->System.out.println(name));
  16.     }
  17. }

Function接口

唯一的抽象方法：R apply(T t);

concat：组合

static Stream concat(Stream<? extends T> a, Stream<? extends T> b): 把参数列表中的两个Stream流对象a和b,合并成一个新的Stream流对象

  1. import java.util.stream.Stream;
  3. public class Demo20StreamConcat {
  4.     public static void main(String[] args) {
  5.         Stream<String> streamA = Stream.of("张无忌");
  6.         Stream<String> streamB = Stream.of("张翠山");
  7.         Stream<String> result = Stream.concat(streamA, streamB);
  8.     }
  9. }

三、Stream综合案例

现在有两个ArrayList集合存储队伍当中的多个成员姓名，要求使用Stream依次进行以下若干操作步骤：

  1. 第一个队伍只要名字为3个字的成员姓名；
  2. 第一个队伍筛选之后只要前3个人；
  3. 第二个队伍只要姓张的成员姓名；
  4. 第二个队伍筛选之后不要前2个人；
  5. 将两个队伍合并为一个队伍；
  6. 根据姓名创建Person对象；

  7. 打印整个队伍的Person对象信息。 ```java public class DemoArrayListNames { public static void main(String[] args) {

    1.  List<String> one = new ArrayList<>();
    2.  one.add("迪丽热巴");
    3.  one.add("宋远桥");
    4.  one.add("苏星河");
    5.  one.add("老子");
    6.  one.add("庄子");
    7.  one.add("孙子");
    8.  one.add("洪七公");
    10.  List<String> two = new ArrayList<>();
    11.  two.add("古力娜扎");
    12.  two.add("张无忌");
    13.  two.add("张三丰");
    14.  two.add("赵丽颖");
    15.  two.add("张二狗");
    16.  two.add("张天爱");
    17.  two.add("张三");
    18.  // ....

    } }

//Stream流式 public class DemoStreamNames { public static void main(String[] args) { List one = new ArrayList<>(); // …

  1.     List<String> two = new ArrayList<>();
  2.     // ...
  4.     // 第一个队伍只要名字为3个字的成员姓名；
  5.     // 第一个队伍筛选之后只要前3个人；
  6.     Stream<String> streamOne = one.stream().filter(s -> s.length() == 3).limit(3);
  8.     // 第二个队伍只要姓张的成员姓名；
  9.     // 第二个队伍筛选之后不要前2个人；
  10.     Stream<String> streamTwo = two.stream().filter(s -> s.startsWith("张")).skip(2);
  12.     // 将两个队伍合并为一个队伍；
  13.     // 根据姓名创建Person对象；
  14.     // 打印整个队伍的Person对象信息。
  15.      Stream.concat(streamOne, streamTwo).map((name)->{return new Person(name);}).forEach((p)->{System.out.println(p);});
  16. }

}

  1. <a name="JYUx3"></a>
  2. ### 收集Stream结果
  3. 对流操作完成之后，如果需要将其结果进行收集，例如获取对应的集合、数组等，如何操作？
  4. <a name="dTC9p"></a>
  5. ### 收集到集合中
  6. > Stream流提供collect方法，其参数需要一个java.util.stream.Collector<T,A, R>接口对象来指定收集到哪种集合中。幸运的是，java.util.stream.Collectors类提供一些方法，可以作为Collector接口的实例：
  7. > - public static <T> Collector<T, ?, List<T>> toList()：转换为List集合。
  8. > - public static <T> Collector<T, ?, Set<T>> toSet()：转换为Set集合
  10. ```java
  11. public class Demo15StreamCollect {
  12.     public static void main(String[] args) {
  13.         Stream<String> stream = Stream.of("10", "20", "30", "40", "50");
  14.         List<String> list = stream.collect(Collectors.toList());
  15.         Set<String> set = stream.collect(Collectors.toSet());
  16.     }
  17. }

收集到数组中

Stream提供toArray方法来将结果放到一个数组中，返回值类型是Object[]的：

Object[] toArray();

  1. import java.util.stream.Stream;
  3. public class Demo16StreamArray {
  4.     public static void main(String[] args) {
  5.         Stream<String> stream = Stream.of("10", "20", "30", "40", "50");
  6.         Object[] objArray = stream.toArray();
  7.     }
  8. }