Java8 中新增的 Stream 流操作

原文地址： 全面吃透JAVA Stream流操作，让代码更加的优雅

---

在 Java 中，涉及到对数组 、Collection等集合类中的元素进行操作的时候，通常会通过循环的方式进行逐个处理，或者是使用Stream的方式进行处理。

先看个示例：

从给定句子中返回单词长度大于5的单词列表，按长度从大到小排序，最多返回3个

public static List<String> sortGetTop3LongWordsByStream(@NotNull String sentence){
    return Arrays.stream(sentence.split(" "))
            .filter(word -> word.length() > 5)
            .sorted(((o1, o2) -> o2.length() - o1.length()))
            .limit(3)
            .collect(Collectors.toList());
}

Stream 初相识

概括讲，可以将 Stream 流操作分为 3 种类型：

• 创建 Stream
• Stream 中间处理
• 终止 Steam

每个 Stream 管道操作类型都包含若干 API 方法，先列举下各个 API 方法的功能介绍。

开始管道

主要负责新建一个 Stream 流，或者基于现有的数组、List、Set、Map 等集合类型对象创建出新的 Stream 流。

API	功能说明
stream()	创建出一个新的 Stream 串行流对象
parallelStream()	创建出一个可并行执行的 Stream 流对象
Stream.of()	通过给定的一系列元素创建一个新的 Stream 串行流对象

中间管道

负责对 Stream 进行处理操作，并返回一个新的 Stream 对象，中间管道操作可以进行叠加 。

API	功能说明
filter()	按照条件过滤符合要求的元素，返回新的 Stream 流
map()	将已有元素转换为另一个对象类型，一对一逻辑，返回新的 Stream 流
flatMap()	将已有元素转换为另一个对象类型，一对多逻辑，即原来一个元素对象可能会转换为一个或者多个新类型的元素，返回新的 Stream 流
limit()	仅保留集合前面指定个数的元素，返回新的 Stream 流
skip()	跳过集合前面指定个数的元素，返回新的 Stream 流
concat()	将两个流的数据合并起来为一个新的流，返回新的 Stream 流
distinct()	对 Stream 流中所有元素进行去重，返回新的 Stream 流
sorted()	对 Stream 流中所有的元素按照指定规则进行排序，返回新的 Stream 流
peek()	对 Stream 流中的每个元素进行逐个遍历处理，返回处理后的 Stream 流

终止管道

顾名思义，通过终止管道操作之后，Stream 流将会结束，最后可能会执行某些逻辑处理，或者是按照要求返回某些执行后的结果数据。

API	功能说明
count()	返回 Stream 处理后最终的元素个数
max()	返回 Stream 处理后的元素最大值
min()	返回 Stream 处理后的元素最小值
findFirst()	找到第一个符合条件的元素时则终止流处理
findAny()	找到任何一个符合条件的元素时则退出流程处理，这个对于串行流时与 findFirst() 相同，对于并行流时比较高效，任何分片中找到都会终止后续计算逻辑
anyMatch()	返回一个 boolean 值，类似于 isContains()，用于判断是否有符合条件的元素
allMatch()	返回一个 boolean 值，用于判断是否所有元素都符合条件
noneMatch()	返回一个 boolean 值，用于判断是否所有元素都不符合条件
collect()	将流转换为指定的类型，通过 Collectors 进行指定
toArray()	将流程转换为数组
iterator()	将流转换为 Iterator 对象
foreach()	无返回值，对元素进行逐个遍历，然后执行给定的处理逻辑

Stream 方法使用

map 与 flatMap

map 与 flatMap 都是用于转换已有的元素为其它元素，区别点在于：

• map 必须是一对一的，即每个元素都只能转换为一个新的元素。
• flatMap 可以是一对多的，即每个元素都可以转换为一个或者多个新的元素。

比如：有一个字符串 ID 列表，现在需要将其转为 User 对象列表 。可以使用 map 来实现：

/**
 * 演示map的用途：一对一转换
 */
public static void stringToIntMap() {
    List<String> ids = Arrays.asList("205","105","308","469","627","193","111");
    // 使用流操作
    List<User> results = ids.stream()
            .map(s -> User.builder().id(Integer.valueOf(s)).build())
            .collect(Collectors.toList());
    System.out.println(results);
}

@Data
@Builder
class User {
    private Integer id;
}

执行之后，会发现每一个元素都被转换为对应新的元素，但是前后总元素个数是一致的：

[User(id=205), User(id=105), User(id=308), User(id=469), User(id=627), User(id=193), User(id=111)]

再比如：现有一个句子列表，需要将句子中每个单词都提取出来得到一个所有单词列表 。这种情况用 map 就搞不定了，需要 flatMap 上场了：

/**
 * 演示flatMap的用途：一对多转换
 */
public static void stringToIntFlatmap() {
    List<String> sentences = Arrays.asList("hello world","Jia Gou Wu Dao");
    // 使用流操作
    List<String> results = sentences.stream()
            .flatMap(sentence -> Arrays.stream(sentence.split(" ")))
            .collect(Collectors.toList());
    System.out.println(results);
}

执行结果如下，可以看到结果列表中元素个数是比原始列表元素个数要多的：

[hello, world, Jia, Gou, Wu, Dao]

这里需要补充一句，flatMap 操作的时候其实是先每个元素处理并返回一个新的 Stream，然后将多个 Stream 展开合并为了一个完整的新的 Stream，如下：

peek 和 foreach

peek 和 foreach，都可以用于对元素进行遍历然后逐个的进行处理。

但根据前面的介绍， peek 属于中间方法 ，而 foreach 属于终止方法 。这也就意味着 peek 只能作为管道中途的一个处理步骤，而没法直接执行得到结果，其后面必须还要有其它终止操作才会被执行；而 foreach 作为无返回值的终止方法，则可以直接执行相关操作。

public static void testPeekAndForeach() {
    List<String> sentences = Arrays.asList("hello world","Jia Gou Wu Dao");
    // 演示点1： 仅peek操作，最终不会执行
    System.out.println("----before peek----");
    sentences.stream().peek(sentence -> System.out.println(sentence));
    System.out.println("----after peek----");
    // 演示点2： 仅foreach操作，最终会执行
    System.out.println("----before foreach----");
    sentences.stream().forEach(sentence -> System.out.println(sentence));
    System.out.println("----after foreach----");
    // 演示点3： peek操作后面增加终止操作，peek会执行
    System.out.println("----before peek and count----");
    //JDK8执行，JDK11不执行
    sentences.stream().peek(sentence -> System.out.println(sentence)).count();
    //JDK8和JDK11都执行
    //sentences.stream().peek(sentence -> System.out.println(sentence)).collect(Collectors.toList());
    System.out.println("----after peek and count----");
}

输出结果可以看出，peek 独自调用时并没有被执行，但 peek 后面加上终止操作之后便可以被执行，而 foreach 可以直接被执行：

----before peek----
----after peek----
----before foreach----
hello world
Jia Gou Wu Dao
----after foreach----
----before peek and count----
hello world
Jia Gou Wu Dao
----after peek and count----

filter、sorted、distinct、limit

这几个都是常用的 Stream 的中间操作方法，具体的方法含义在上面的表格里面有说明。具体使用的时候，可以根据需要选择一个或者多个进行组合使用，或者同时使用多个相同方法的组合：

public static void testGetTargetUsers() {
    List<String> ids = Arrays.asList("205", "10", "308", "49", "627", "193", "111", "193");
    // 使用流操作
    List<Dept> results = ids.stream()
            // 使用 filter 过滤掉不符合条件的数据
            .filter(s -> s.length() > 2)
            // 通过 distinct 对存量元素进行去重操作
            .distinct()
            // 通过 map 操作将字符串转成整数类型
            .map(Integer::valueOf)
            //借助 sorted 指定按照数字从小到大正序排列
            .sorted(Comparator.comparingInt(o -> o))
            // 使用 limit 截取排在前3位的元素
            .limit(3)
            // 又一次使用 map 将 id 转为 Dept 对象类型
            .map(Dept::new)
            // 使用 collect 终止操作将最终处理后的数据收集到 list 中
            .collect(Collectors.toList());
    System.out.println(results);
}

@Data
@AllArgsConstructor
class Dept {
    private Integer id;
}

输出结果：

[Dept(id=111), Dept(id=193), Dept(id=205)]

简单结果终止方法

按照前面介绍的，终止方法里面像 count、 max、 min、 findAny、 findFirst、 anyMatch、 allMatch、 nonneMatch 等方法，均属于这里说的简单结果终止方法。所谓简单，指的是其结果形式是数字、布尔值或者 Optional 对象值等。

public static void testSimpleStopOptions() {
    List<String> ids = Arrays.asList("205", "10", "308", "49", "627", "193", "111", "193");
    // count 统计 Stream 操作后剩余的元素个数
    System.out.println(ids.stream().filter(s -> s.length() > 2).count());
    // anyMatch 判断是否有元素值等于 205
    System.out.println(ids.stream().filter(s -> s.length() > 2).anyMatch("205"::equals));
    // findFirst操作，找到第一个长度大于 2 的值
    ids.stream().filter(s -> s.length() > 2)
            .findFirst()
            .ifPresent(s -> System.out.println("findFirst: " + s));
}

输出结果：

6
true
findFirst: 205

避坑提醒

这里需要补充提醒下， 一旦一个 Stream 被执行了终止操作之后，后续便不可以再读这个流执行其他的操作了，否则会报错，看下面示例：

public static void testHandleStreamAfterClosed() {
    List<String> ids = Arrays.asList("205", "10", "308", "49", "627", "193", "111", "193");
    Stream<String> stream = ids.stream().filter(s -> s.length() > 2);
    // 统计 Stream 操作后剩余的元素个数
    System.out.println(stream.count());
    System.out.println("-----下面会报错-----");
    // 判断是否有元素值等于 205
    try {
        System.out.println(stream.anyMatch("205"::equals));
    } catch (Exception e) {
        e.printStackTrace();
    }
    System.out.println("-----上面会报错-----");
}

执行的时候，结果如下：

6
-----下面会报错-----
java.lang.IllegalStateException: stream has already been operated upon or closed
	at java.util.stream.AbstractPipeline.evaluate(AbstractPipeline.java:229)
	at java.util.stream.ReferencePipeline.anyMatch(ReferencePipeline.java:449)
	at com.example.demo.stream.Test.testHandleStreamAfterClosed(Test.java:29)
	at com.example.demo.stream.Test.main(Test.java:18)
-----上面会报错-----

因为 Stream 已经被执行 count() 终止方法了，所以对 Stream 再执行 anyMatch() 方法的时候，就会报错stream has already been operated upon or closed，这一点在使用的时候需要特别注意。

结果收集终止方法

因为 Stream 主要用于对集合数据的处理场景，所以除了上面几种获取简单结果的终止方法之外，更多的场景是获取一个集合类的结果对象，比如 List、Set 或者 HashMap 等。

这里就需要 collect 方法出场了，它可以支持生成如下类型的结果数据：

• 集合类
• 字符串进行拼接
• 数据批量运算统计

生成集合

应该算是 collect 最常被使用到的一个场景了：

public static void testCollectStopOptions() {
    List<Dept> ids = Arrays.asList(new Dept(17), new Dept(22), new Dept(23));
    // collect 成 list
    List<Dept> collectList = ids.stream().filter(dept -> dept.getId() > 20).collect(Collectors.toList());
    System.out.println("collectList:" + collectList);
    // collect 成 Set
    Set<Dept> collectSet = ids.stream().filter(dept -> dept.getId() > 20).collect(Collectors.toSet());
    System.out.println("collectSet:" + collectSet);
    // collect 成 HashMap，key 为 id，value 为 Dept 对象
    Map<Integer, Dept> collectMap = ids.stream().filter(dept -> dept.getId() > 20).collect(Collectors.toMap(Dept::getId, dept -> dept));
    System.out.println("collectMap:" + collectMap);
}

结果如下：

collectList:[Dept(id=22), Dept(id=23)]
collectSet:[Dept(id=22), Dept(id=23)]
collectMap:{22=Dept(id=22), 23=Dept(id=23)}

生成拼接字符串

将一个 List 或者数组中的值拼接到一个字符串里并以逗号分隔开，这个场景相信大家都不陌生吧？

如果通过 for 循环和 StringBuilder 去循环拼接，还得考虑下最后一个逗号如何处理的问题，很繁琐，但是现在有了 Stream，使用 collect 可以轻而易举的实现：

public static void testCollectJoinStrings() {
    List<String> ids = Arrays.asList("205", "10", "308", "49", "627", "193", "111", "193");
    String joinResult = ids.stream().filter(i -> i.length() > 2).collect(Collectors.joining(","));
    System.out.println("拼接后：" + joinResult);
}

输出：

拼接后：205,308,627,193,111,193

数据批量数学运算

还有一种场景，实际使用的时候可能会比较少，就是使用 collect 生成数字数据的总和信息，也可以了解下实现方式：

public static void testNumberCalculate() {
    List<Integer> ids = Arrays.asList(10, 20, 30, 40, 50);
    // 计算平均值
    Double average = ids.stream().collect(Collectors.averagingInt(value -> value));
    System.out.println("平均值：" + average);
    // 数据统计信息
    IntSummaryStatistics summary = ids.stream().collect(Collectors.summarizingInt(value -> value));
    System.out.println("数据统计信息： " + summary);
}

上面的例子中，使用 collect 方法来对 list 中元素值进行数学运算，结果如下：

平均值：30.0
数据统计信息： IntSummaryStatistics{count=5, sum=150, min=10, average=30.000000, max=50}

并行 Stream

机制说明

使用并行流，可以有效利用计算机的多 CPU 硬件，提升逻辑的执行速度。并行流通过将一整个 Stream 划分为多个片段，然后对各个分片流并行执行处理逻辑，最后将各个分片流的执行结果汇总为一个整体流。

约束与限制

并行流类似于多线程在并行处理，所以与多线程场景相关的一些问题同样会存在，比如死锁等问题，所以在并行流终止执行的函数逻辑，必须要保证线程安全。

Stream 相较于传统的 foreach 的方式，到底有啥优势？

根据前面的介绍，我们应该可以得出如下几点答案：

• 代码更简洁，偏声明式的编码风格，更容易体现出代码的逻辑意图。
• 逻辑间解耦，一个 Stream 中间处理逻辑，无需关注上游与下游的内容，只需要按约定实现自身逻辑即可。
• 并行流场景效率会比迭代器逐个循环更高。
• 函数式接口，延迟执行的特性，中间管道操作不管有多少步骤都不会立即执行，只有遇到终止操作的时候才会开始执行，可以避免一些中间不必要的操作消耗。

当然了，Stream 也不全是优点，在有些方面也有其弊端：

• 代码调测 debug 不方便。
• 程序员从历史写法切换到 Stream 时，需要一定的适应时间。