写点什么

全面吃透 JAVA Stream 流操作,让代码更加的优雅

作者:Java-fenn
  • 2022 年 9 月 13 日
    湖南
  • 本文字数:6661 字

    阅读完需:约 22 分钟

大家好,又见面啦。

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

例如,现在有这么一个需求:

从给定句子中返回单词长度大于 5 的单词列表,按长度倒序输出,最多返回 3 个

在 JAVA7 及之前 的代码中,我们会可以照如下的方式进行实现:

/** * 【常规方式】 * 从给定句子中返回单词长度大于5的单词列表,按长度倒序输出,最多返回3个 * * @param sentence 给定的句子,约定非空,且单词之间仅由一个空格分隔 * @return 倒序输出符合条件的单词列表 */public List<String> sortGetTop3LongWords(@NotNull String sentence) {    // 先切割句子,获取具体的单词信息    String[] words = sentence.split(" ");    List<String> wordList = new ArrayList<>();    // 循环判断单词的长度,先过滤出符合长度要求的单词    for (String word : words) {        if (word.length() > 5) {            wordList.add(word);        }    }    // 对符合条件的列表按照长度进行排序    wordList.sort((o1, o2) -> o2.length() - o1.length());    // 判断list结果长度,如果大于3则截取前三个数据的子list返回    if (wordList.size() > 3) {        wordList = wordList.subList(0, 3);    }    return wordList;}
复制代码

在 JAVA8 及之后 的版本中,借助 Stream 流,我们可以更加优雅的写出如下代码:

/** * 【Stream方式】 * 从给定句子中返回单词长度大于5的单词列表,按长度倒序输出,最多返回3个 * * @param sentence 给定的句子,约定非空,且单词之间仅由一个空格分隔 * @return 倒序输出符合条件的单词列表 */public 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 流,但是对 Stream 流的认知往往也是仅限于会一些简单的 ​ ​filter​ ​、​ ​map​ ​、​ ​collect​ ​等操作,但 JAVA 的 Stream 可以适用的场景与能力远不止这些。



那么问题来了: Stream 相较于传统的 foreach 的方式处理 stream,到底有啥优势 ?

这里我们可以先搁置这个问题,先整体全面的了解下 Stream,然后再来讨论下这个问题。

笔者结合在团队中多年的代码检视遇到的情况,结合平时项目编码实践经验,对 Stream 的核心要点与易混淆用法 、 典型使用场景 等进行了详细的梳理总结,希望可以帮助大家对 Stream 有个更全面的认知,也可以更加高效的应用到项目开发中去。

Stream 初相识

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

  • 创建 Stream

  • Stream 中间处理

  • 终止 Steam



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

  • 开始管道

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



  • 中间管道

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



  • 终止管道

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

Stream 方法使用

map 与 flatMap

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

  • map 必须是一对一的 ,即每个元素都只能转换为 1 个新的元素

  • flatMap 可以是一对多的 ,即每个元素都可以转换为 1 个或者多个新的元素



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

/** * 演示map的用途:一对一转换 */public void stringToIntMap() {    List<String> ids = Arrays.asList("205", "105", "308", "469", "627", "193", "111");    // 使用流操作    List<User> results = ids.stream()            .map(id -> {                User user = new User();                user.setId(id);                return user;            })            .collect(Collectors.toList());    System.out.println(results);}
复制代码

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

[User{id='205'},  User{id='105'}, User{id='308'},  User{id='469'},  User{id='627'},  User{id='193'},  User{id='111'}]
复制代码



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

public 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 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----");    sentences.stream().peek(sentence -> System.out.println(sentence)).count();    System.out.println("----after peek and count----");}
复制代码

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

----before peek--------after peek--------before foreach----hello worldJia Gou Wu Dao----after foreach--------before peek and count----hello worldJia Gou Wu Dao----after peek and count----

复制代码



filter、sorted、distinct、limit

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

public void testGetTargetUsers() {    List<String> ids = Arrays.asList("205","10","308","49","627","193","111", "193");    // 使用流操作    List<Dept> results = ids.stream()            .filter(s -> s.length() > 2)            .distinct()            .map(Integer::valueOf)            .sorted(Comparator.comparingInt(o -> o))            .limit(3)            .map(id -> new Dept(id))            .collect(Collectors.toList());    System.out.println(results);}
复制代码

上面的代码片段的处理逻辑很清晰:

  1. 使用 filter 过滤掉不符合条件的数据

  2. 通过 distinct 对存量元素进行去重操作

  3. 通过 map 操作将字符串转成整数类型

  4. 借助 sorted 指定按照数字大小正序排列

  5. 使用 limit 截取排在前 3 位的元素

  6. 又一次使用 map 将 id 转为 Dept 对象类型

  7. 使用 collect 终止操作将最终处理后的数据收集到 list 中

输出结果:

[Dept{id=111},  Dept{id=193},  Dept{id=205}]
复制代码



简单结果终止方法

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

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

执行后结果为:

6truefindFirst:205
复制代码



避坑提醒

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

public 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.eval(AbstractPipeline.java:229)  at java.util.stream.ReferencePipeline.anyMatch(ReferencePipeline.java:449)  at com.veezean.skills.stream.StreamService.testHandleStreamAfterClosed(StreamService.java:153)  at com.veezean.skills.stream.StreamService.main(StreamService.java:176)-----上面会报错-----
复制代码

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



结果收集终止方法

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

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

​集合类​​字符串进行拼接​​数据批量运算统计​
复制代码



生成集合

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

public 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=23}, Dept{id=22}]collectMap:{22=Dept{id=22}, 23=Dept{id=23}}
复制代码



生成拼接字符串

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

如果通过 ​ ​for​ ​循环和 ​ ​StringBuilder​ ​去循环拼接,还得考虑下最后一个逗号如何处理的问题,很繁琐:

public void testForJoinStrings() {    List<String> ids = Arrays.asList("205", "10", "308", "49", "627", "193", "111", "193");    StringBuilder builder = new StringBuilder();    for (String id : ids) {        builder.append(id).append(',');    }    // 去掉末尾多拼接的逗号    builder.deleteCharAt(builder.length() - 1);    System.out.println("拼接后:" + builder.toString());}
复制代码

但是现在有了 Stream,使用 ​ ​collect​ ​可以轻而易举的实现:

public void testCollectJoinStrings() {    List<String> ids = Arrays.asList("205", "10", "308", "49", "627", "193", "111", "193");    String joinResult = ids.stream().collect(Collectors.joining(","));    System.out.println("拼接后:" + joinResult);}
复制代码

两种方式都可以得到完全相同的结果,但 Stream 的方式更优雅:

拼接后:205,10,308,49,627,193,111,193
复制代码



数据批量数学运算

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

public 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 划分为 ​ ​多个片段​ ​,然后对各个分片流并行执行处理逻辑,最后将各个分片流的执行结果汇总为一个整体流。



约束与限制

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



回答最初的问题

到这里,关于 JAVA Stream 的相关概念与用法介绍,基本就讲完了。我们再把焦点切回本文刚开始时提及的一个问题:

Stream 相较于传统的 foreach 的方式处理 stream,到底有啥优势?

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

  • 代码更简洁 、偏声明式的编码风格,更容易体现出代码的逻辑意图

  • 逻辑间解耦 ,一个 stream 中间处理逻辑,无需关注上游与下游的内容,只需要按约定实现自身逻辑即可

  • 并行流场景 效率 会比迭代器逐个循环更高

  • 函数式接口, 延迟执行 的特性,中间管道操作不管有多少步骤都不会立即执行,只有遇到终止操作的时候才会开始执行,可以避免一些中间不必要的操作消耗

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

  • 代码调测 debug 不便

  • 程序员从历史写法切换到 Stream 时,需要一定的适应时间



总结

好啦,关于 JAVA Stream 的理解要点与使用技能的阐述就先到这里啦。那通过上面的介绍,各位小伙伴们是否已经跃跃欲试了呢?快去项目中使用体验下吧!当然啦,如果有疑问,也欢迎找我一起探讨探讨咯。

用户头像

Java-fenn

关注

需要Java资料或者咨询可加我v : Jimbye 2022.08.16 加入

还未添加个人简介

评论

发布
暂无评论
全面吃透JAVA Stream流操作,让代码更加的优雅_Java_Java-fenn_InfoQ写作社区