JAVA8新特性--集合流操作Stream

谁践踏了优雅 2021-09-15 06:12 490阅读 0赞

Stream类全路径为：java.util.stream.Stream  
对Stream的描述，引用其他文章中觉得比较好的介绍：

> Java 8 中的 Stream 是对集合（Collection）对象功能的增强，它专注于对集合对象进行各种非常便利、高效的聚合操作（aggregate operation），或者大批量数据操作 (bulk data operation)。Stream API 借助于同样新出现的 Lambda 表达式，极大的提高编程效率和程序可读性。

即Stream的原理：

> 这种风格将要处理的元素集合看作一种流， 流在管道中传输， 并且可以在管道的节点上进行处理， 比如筛选， 排序，聚合等。元素流在管道中经过中间操作（intermediate operation）的处理，最后由最终操作(terminal operation)得到前面处理的结果。

集合有两种方式生成流：

*  stream() − 为集合创建串行流。
 *  parallelStream() − 为集合创建并行流。

并发模式（parallelStream）能够充分利用多核处理器的优势，使用 fork/join 并行方式来拆分任务和加速处理过程。java中也提供了多种并行处理的方式，看到一片文章对各几种并行的方式性能进行了测试，可以参考下：[java中几种并行方式的性能分析][java]。

Stream的的**中间操作**（intermediate）和**最终操作**（terminal）都包含哪些方法可以从类结构中看到：  
![这里写图片描述][70]  
![这里写图片描述][70 1]  
上面截图基本包含了Strram的所有方法。

*  中间操作（intermediate）主要有以下方法（此类型的方法返回的都是Stream对象）：  
    map (mapToInt, flatMap 等)、 filter、 distinct、 sorted、 peek、 limit、 skip、 parallel、 sequential、 unordered
 *  终端操作（terminal）主要有以下方法：  
    forEach、 forEachOrdered、 toArray、 reduce、 collect、 min、 max、 count、 anyMatch、 allMatch、 noneMatch、 findFirst、 findAny、 iterator

此处按照类结构（截图）中的方法的顺序（*以下例子中使用了Lambda表达式及方法引用，不了解的请戳*：[Lambda介绍][Lambda]，[方法引用][Link 1]），进行介绍：

*  **filter**：通过设置条件来过滤元素。

List<String> list = Arrays.asList("aaa","ddd","bbb","ccc","a2a","d2d","b2b","c2c","a3a","d3d","b3b","c3c");
    
    list.stream()
            .filter((s)->s.contains("a"))
            .forEach(s -> System.out.println(s));

以上代码使用filter方法过滤出只包含"a"的元素，然后通过forEach将满足条件的元素遍历出来。输出如下：

> aaa  
> a2a  
> a3a

*  **map**：就是将对应的元素使用给定方法进行转换。

list.stream()
            .filter((s)->s.contains("a"))
            .map((s)-> s + "---map")
            .forEach(s -> System.out.println(s));

在filter的基础上，给每个元素后面添加字符串"—map"，输出如下：

> aaa—map  
> a2a—map  
> a3a—map

*  **mapToInt**：和map方法进行一样的操作，但是转换函数必须返回int类型
 *  **mapToLong**：和map方法进行一样的操作，但是转换函数必须返回long类型
 *  **mapToDouble**：和map方法进行一样的操作，但是转换函数必须返回double类型  
    此处以mapToInt进行演示：

list.stream()
            .filter((s)->s.contains("a"))
            .mapToInt((s)-> s.hashCode())
            .forEach(s -> System.out.println(s));

在filter的基础上，将每个元素转换为其hashCode。输出为：

> 96321  
> 94864  
> 94895

*  **flatMap**：如果流的元素为数组或者Collection，flatMap就是将每个Object\[\]元素或Collection<Object>元素都转换为Object元素，如下：

> Stream<String\[\]> 转换为 Stream<String>  
> Stream<Set> 转换为 Stream<String>  
> Stream<List> 转换为 Stream<String>  
> Stream<List> 转换为 Stream<Object>

看下例子：

List<String[]> setList =  new ArrayList<>();
    setList.add(new String[]{ "aa","bb"});
    setList.add(new String[]{ "cc","dd"});
    setList.add(new String[]{ "ee","ff"});
    //使用map方法
    setList.stream()
            .map(s->Arrays.stream(s))
            .forEach(s-> System.out.println("map==" + s));
    //使用flatMap方法
    setList.stream()
            .flatMap(s->Arrays.stream(s))
            .forEach(s-> System.out.println("flatMap==" + s));

输出如下：

> mapjava.util.stream.ReferencePipeline&Head@50040f0c  
> mapjava.util.stream.ReferencePipeline&Head@2dda6444  
> mapjava.util.stream.ReferencePipeline&Head@5e9f23b4  
> flatMapaa  
> flatMapbb  
> flatMapcc  
> flatMapdd  
> flatMapee  
> flatMap==ff

可以看出map就是将数组流直接返回，flatMap是将数组流中的每个元素都返回。**flatMapToInt**，**flatMapToLong**，**flatMapToDouble**类似，只不过返回的是对应的类型的流，此处不做演示。

*  **distinct**：将集合中的元素去重。

List<String> disList = Arrays.asList("aaa","ddd","bbb","ddd","aaa");
    disList.stream()
            .distinct()
            .forEach(s-> System.out.println(s));

输出如下：

> aaa  
> ddd  
> bbb

*  **sorted**：将集合中的元素排序。

List<Integer> integerList = Arrays.asList(1,2,3,4);
    integerList.stream()
            .sorted()
            .forEach(s-> System.out.println(s));

输出如下：

> 1  
> 2  
> 3  
> 4

可以按照自定义排序：

integerList.stream()
            .sorted((s1,s2)->s2.compareTo(s1))
            .forEach(s-> System.out.println(s));

输出如下：

> 4  
> 3  
> 2  
> 1

*  peek：生成一个包含原Stream的所有元素的新Stream，同时会提供一个消费函数即引用的方法A，当Stream每个元素被消费的时候都会先执行新Stream给定的方法A。peek是**中间操作**，如果pee后没有**最终操作**，则peek不会执行。

integerList.stream()
            .peek(s-> System.out.println("peek = "+s));

此时没有输出，代码改为：

integerList.stream()
            .peek(s-> System.out.println("peek = "+s))
            .forEach(s-> System.out.println("forEach = "+s));

输出如下：

> peek = 1  
> forEach = 1  
> peek = 2  
> forEach = 2  
> peek = 3  
> forEach = 3  
> peek = 4  
> forEach = 4

*  **limit**：返回Stream的前n个元素。

integerList.stream()
            .limit(1)
            .forEach(s-> System.out.println(s));

输出为：

> 1

*  **skip**：删除Stream的前n个元素。

integerList.stream()
            .skip(1)
            .forEach(s-> System.out.println(s));

输出如下：

> 2  
> 3  
> 4

*  **forEach**：遍历Stream中的每个元素，前面每个例子都有使用，此处不再演示。
 *  **forEachOrdered**:遍历Stream中的每个元素。  
    **区别**：  
    在串行流（stream）中没有区别，在并行流（parallelStream）中如果数据源是有序集合，**forEachOrdered**输出顺序与数据源中顺序一致，**forEach**则是乱序。

看下使用forEach：

integerList.parallelStream()
            .forEach(s-> System.out.println(s));

输出（多次测试，每次结果都不一样）：

> 3  
> 1  
> 4  
> 2

再看使用forEachOrdered：

integerList.parallelStream()
            .forEachOrdered(s-> System.out.println(s));

输出（测试多次，每次都是这个结果，与integerList中的元素顺序一致）：

> 2  
> 1  
> 3  
> 4

*  **toArray**：将流转换为Object\[\]或者指定类型的数组。

Object[] array = integerList.stream().toArray();
    String[] strArr = integerList.stream().toArray(String[]::new);

*  **reduce**：将集合中的每个元素聚合成一条数据。有三种情况：

--------------------

*  reduce(BinaryOperator accumulator)：此处需要一个参数，返回Optional对象：

Optional<Integer> reduce = integerList.stream().reduce((a, b) -> a + b);

*  reduce(T identity, BinaryOperator accumulator)：此处需要两个参数，第一个参数为起始值，第二个参数为引用的方法。从起始值开始，每个元素执行一次引用的方法（方法引用的中的两个参数：第一个参数为上个元素执行方法引用的结果，第二个参数为当前元素）。

int integer = integerList.stream().reduce(5,(a, b) -> a + b);
    System.out.println(integer);

输出为：

> 15

此例中使用起始值为5，对集合中每个元素求和，可以理解为：5+2+1+3+4=15。

*  reduce(U **identity**, BiFunction<U, ? super T, U> **accumulator**, BinaryOperator<U> **combiner**)：此处需要三个参数。此方法用在并发流（parallelStream）中，启动多个子线程使用**accumulator**进行并行计算，最终使用**combiner**对子线程结果进行合并，返回identity类型的数据，看到有篇文章对这个解释比较清楚：[java8中3个参数的reduce方法怎么理解？][java8_3_reduce]
 *  **collect**：将流转换成集合或聚合元素。有两种情况。接受一个参数和接受三个参数（三个参数在并发流parallelStream中使用），此处介绍一个参数的情况，单个参数接受的参数类型为Collector，Collectors 类实现了很多归约操作，详见：[java8之collector][java8_collector]

List<Integer> collects = integerList.stream()
            .filter(a -> a > 1)
            .collect(Collectors.toList());
    System.out.println(collects);

此处统计集合中大于1的元素并最终返回list。输出如下：

> \[2, 3, 4\]

*  **min**:获取集合中最小值。

Integer min = integerList.stream()
            .filter(a -> a > 1)
            .min((Integer a, Integer b) -> a.compareTo(b))
            .get();
    System.out.println(min);

输出为：

> 2

*  **max**：获取集合中最大值。

Integer max = integerList.stream()
            .filter(a -> a > 1)
            .max((Integer a, Integer b) -> a.compareTo(b))
            .get();
    System.out.println(max);

输出为：

> 4

*  **count**：获取集合中元素个数

long count = integerList.stream()
            .filter(a -> a > 1)
            .count();
    System.out.println(count);

输出为：

> 3

*  anyMatch： Stream 中任意一个元素符合传入的 predicate，返回 true
 *  allMatch：Stream 中全部元素符合传入的 predicate，返回 true
 *  noneMatch：Stream 中没有一个元素符合传入的 predicate，返回 true

boolean b = integerList.stream()
            .anyMatch(s -> s > 0);
    boolean b1 = integerList.stream()
            .allMatch(s -> s > 0);
    boolean b2 = integerList.stream()
            .noneMatch(s -> s > 0);
    System.out.println("anyMatch = " + b);
    System.out.println("allMatch = " + b1);
    System.out.println("noneMatch = " + b2);

输出：

> anyMatch = true  
> allMatch = true  
> noneMatch = false

*  findFirst：如果数据源是有序集合，返回Stream 中第一个元素的Optional对象，如果是无序集合，则返回Stream 中任意一个元素的Optional对象。

Integer first = integerList.stream()
            .findFirst()
            .get();
    System.out.println(first);

输出为：

> 2

*  findAny：返回Stream 中任意一个元素的Optional对象。

Integer any = integerList.stream()
            .findAny()
            .get();
    System.out.println(any);

输出为：

> 2

Stream还有几个静态方法，返回都是Stream对象。  
静态方法如下：builder（返回Builder对象）、empty、of、iterate、generate、concat。  
**builder**：返回一个Builder对象，Builder对象在调用build()返回Stream对象。  
**empty**：返回一个空的有序的Stream对象。  
**of**：返回包含单个元素的有序的Stream对象。  
**iterate**：返回一个无限元素的有序的Stream对象。需要两个参数，第一个参数为初始值，第二个参数为要引用的方法，然后会通过递归循环调用引用的方法。

Stream.iterate(2,s->s+s)
            .limit(10)
            .forEach(s-> System.out.println(s));

输出为：

> 2  
> 4  
> 8  
> 16  
> 32  
> 64  
> 128  
> 256  
> 512  
> 1024

**generate**：返回一个无限元素的无序的的Stream对象。需要一个参数，参数为引用的方法，然后会通过循环调用引用的方法来生成元素，常用于生成常量Stream和随机元素Stream。  
**concat**：将两个Stream连接成一个Stream。需要两个Stream作为参数，如果两个Stream都是有序的并且无论参数Stream是否是并行Stream，得到的都是有序的Stream。输出元素顺序为先输出第一个Stream的元素，然后输出第二个Stream的元素。当结果Stream关闭时候，两个参数Stream同时关闭。

Stream.concat(integerList.stream(),disList.stream())
            .forEach(s-> System.out.println(s));

输出为：

> 2  
> 1  
> 3  
> 4  
> 11  
> aaa  
> ddd  
> 33  
> bbb  
> ddd  
> aaa

[java]: https://my.oschina.net/wangbo888/blog/1635744
[70]: /images/20210607/850b5360fd2343ffb8cc1aceeffb26aa.png
[70 1]: /images/20210607/7aefc64915b04fb68b81eea7931aa399.png
[Lambda]: https://blog.csdn.net/bluuusea/article/details/79934078
[Link 1]: https://blog.csdn.net/bluuusea/article/details/79954570
[java8_3_reduce]: https://segmentfault.com/q/1010000004944450
[java8_collector]: https://www.jianshu.com/p/c0d5c3094324