JDK8 Stream 数据流效率分析

Stream 是Java SE 8类库中新增的关键抽象,它被定义于 java.util.stream (这个包里有若干流类型: Stream<T> 代表对象引用流,此外还有一系列特化流,如 IntStream,LongStream,DoubleStream等 ),Java 8 引入的的Stream主要用于取代部分Collection的操作,每个流代表一个值序列,流提供一系列常用的聚集操作,可以便捷的在它上面进行各种运算。集合类库也提供了便捷的方式使我们可以以操作流的方式使用集合、数组以及其它数据结构;

stream 的操作种类

①中间操作

- 当数据源中的数据上了流水线后,这个过程对数据进行的所有操作都称为“中间操作”;

- 中间操作仍然会返回一个流对象,因此多个中间操作可以串连起来形成一个流水线;

- stream 提供了多种类型的中间操作,如 filter、distinct、map、sorted 等等;

②终端操作 

- 当所有的中间操作完成后,若要将数据从流水线上拿下来,则需要执行终端操作;

- stream 对于终端操作,可以直接提供一个中间操作的结果,或者将结果转换为特定的 collection、array、String 等;

这一部分详细的说明可以参见:JDK8 Stream 详细使用

stream 的特点

①只能遍历一次:

数据流的从一头获取数据源,在流水线上依次对元素进行操作,当元素通过流水线,便无法再对其进行操作,可以重新在数据源获取一个新的数据流进行操作;

②采用内部迭代的方式:

对Collection进行处理,一般会使用 Iterator 遍历器的遍历方式,这是一种外部迭代;

而对于处理Stream,只要申明处理方式,处理过程由流对象自行完成,这是一种内部迭代,对于大量数据的迭代处理中,内部迭代比外部迭代要更加高效;

stream 相对于 Collection 的优点

  • 无存储:流并不存储值;流的元素源自数据源(可能是某个数据结构、生成函数或I/O通道等等),通过一系列计算步骤得到;
  • 函数式风格:对流的操作会产生一个结果,但流的数据源不会被修改;
  • 惰性求值:多数流操作(包括过滤、映射、排序以及去重)都可以以惰性方式实现。这使得我们可以用一遍遍历完成整个流水线操作,并可以用短路操作提供更高效的实现;
  • 无需上界:不少问题都可以被表达为无限流(infinite stream):用户不停地读取流直到满意的结果出现为止(比如说,枚举 完美数 这个操作可以被表达为在所有整数上进行过滤);集合是有限的,但流可以表达为无线流;
  • 代码简练:对于一些collection的迭代处理操作,使用 stream 编写可以十分简洁,如果使用传统的 collection 迭代操作,代码可能十分啰嗦,可读性也会比较糟糕;

stream 和 iterator 迭代的效率比较

好了,上面 stream 的优点吹了那么多,stream 函数式的写法是很舒服,那么 steam 的效率到底怎样呢?

先说结论:

- 传统 iterator (for-loop) 比 stream(JDK8) 迭代性能要高,尤其在小数据量的情况下;

- 在多核情景下,对于大数据量的处理,parallel stream 可以有比 iterator 更高的迭代处理效率;

我分别对一个随机数列 List (数量从 10 到 10000000)进行映射、过滤、排序、规约统计、字符串转化场景下,对使用 stream 和 iterator 实现的运行效率进行了统计,测试代码 基准测试代码链接

测试环境如下:

System:Ubuntu 16.04 xenial

CPU:Intel Core i7-8550U

RAM:16GB

JDK version:1.8.0_151

JVM:HotSpot(TM) 64-Bit Server VM (build 25.151-b12, mixed mode)

JVM Settings:

    -Xms1024m

    -Xmx6144m

    -XX:MaxMetaspaceSize=512m

    -XX:ReservedCodeCacheSize=1024m

    -XX:+UseConcMarkSweepGC

    -XX:SoftRefLRUPolicyMSPerMB=100

1. 映射处理测试

把一个随机数列(List<Integer>)中的每一个元素自增1后,重新组装为一个新的 List<Integer>,测试的随机数列容量从 10 - 10000000,跑10次取平均时间;


  1. //stream
  2. List<Integer> result = list.stream()
  3. .mapToInt(x -> x)
  4. .map(x -> ++x)
  5. .boxed()
  6. .collect(Collectors.toCollection(ArrayList::new));
  7. //iterator
  8. List<Integer> result = new ArrayList<>();
  9. for(Integer e : list){
  10. result.add(++e);
  11. }
  12. //parallel stream
  13. List<Integer> result = list.parallelStream()
  14. .mapToInt(x -> x)
  15. .map(x -> ++x)
  16. .boxed()
  17. .collect(Collectors.toCollection(ArrayList::new));

2. 过滤处理测试

取出一个随机数列(List<Integer>)中的大于 200 的元素,并组装为一个新的 List<Integer>,测试的随机数列容量从 10 - 10000000,跑10次取平均时间;


  1. //stream
  2. List<Integer> result = list.stream()
  3. .mapToInt(x -> x)
  4. .filter(x -> x > 200)
  5. .boxed()
  6. .collect(Collectors.toCollection(ArrayList::new));
  7. //iterator
  8. List<Integer> result = new ArrayList<>(list.size());
  9. for(Integer e : list){
  10. if(e > 200){
  11. result.add(e);
  12. }
  13. }
  14. //parallel stream
  15. List<Integer> result = list.parallelStream()
  16. .mapToInt(x -> x)
  17. .filter(x -> x > 200)
  18. .boxed()
  19. .collect(Collectors.toCollection(ArrayList::new));

3. 自然排序测试

对一个随机数列(List<Integer>)进行自然排序,并组装为一个新的 List<Integer>,iterator 使用的是 Collections # sort API(使用归并排序算法实现),测试的随机数列容量从 10 - 10000000,跑10次取平均时间;


  1. //stream
  2. List<Integer> result = list.stream()
  3. .mapToInt(x->x)
  4. .sorted()
  5. .boxed()
  6. .collect(Collectors.toCollection(ArrayList::new));
  7. //iterator
  8. List<Integer> result = new ArrayList<>(list);
  9. Collections.sort(result);
  10. //parallel stream
  11. List<Integer> result = list.parallelStream()
  12. .mapToInt(x->x)
  13. .sorted()
  14. .boxed()
  15. .collect(Collectors.toCollection(ArrayList::new));

4. 归约统计测试

获取一个随机数列(List<Integer>)的最大值,测试的随机数列容量从 10 - 10000000,跑10次取平均时间;


  1. //stream
  2. int max = list.stream()
  3. .mapToInt(x -> x)
  4. .max()
  5. .getAsInt();
  6. //iterator
  7. int max = -1;
  8. for(Integer e : list){
  9. if(e > max){
  10. max = e;
  11. }
  12. }
  13. //parallel stream
  14. int max = list.parallelStream()
  15. .mapToInt(x -> x)
  16. .max()
  17. .getAsInt();

5. 字符串拼接测试

获取一个随机数列(List<Integer>)各个元素使用“,”分隔的字符串,测试的随机数列容量从 10 - 10000000,跑10次取平均时间;


  1. //stream
  2. String result = list.stream().map(String::valueOf).collect(Collectors.joining(","));
  3. //iterator
  4. StringBuilder builder = new StringBuilder();
  5. for(Integer e : list){
  6. builder.append(e).append(",");
  7. }
  8. String result = builder.length() == 0 ? "" : builder.substring(0,builder.length() - 1);
  9. //parallel stream
  10. String result = list.stream().map(String::valueOf).collect(Collectors.joining(","));

6. 混合操作测试

对一个随机数列(List<Integer>)进行去空值,除重,映射,过滤,并组装为一个新的 List<Integer>,测试的随机数列容量从 10 - 10000000,跑10次取平均时间;


  1. //stream
  2. List<Integer> result = list.stream()
  3. .filter(Objects::nonNull)
  4. .mapToInt(x -> x + 1)
  5. .filter(x -> x > 200)
  6. .distinct()
  7. .boxed()
  8. .collect(Collectors.toCollection(ArrayList::new));
  9. //iterator
  10. HashSet<Integer> set = new HashSet<>(list.size());
  11. for(Integer e : list){
  12. if(e != null && e > 200){
  13. set.add(e + 1);
  14. }
  15. }
  16. List<Integer> result = new ArrayList<>(set);
  17. //parallel stream
  18. List<Integer> result = list.parallelStream()
  19. .filter(Objects::nonNull)
  20. .mapToInt(x -> x + 1)
  21. .filter(x -> x > 200)
  22. .distinct()
  23. .boxed()
  24. .collect(Collectors.toCollection(ArrayList::new));

实验结果总结

从以上的实验来看,可以总结处以下几点:

- 在少低数据量的处理场景中(size<=1000),stream 的处理效率是不如传统的 iterator 外部迭代器处理速度快的,但是实际上这些处理任务本身运行时间都低于毫秒,这点效率的差距对普通业务几乎没有影响,反而 stream 可以使得代码更加简洁;

- 在大数据量(szie>10000)时,stream 的处理效率会高于 iterator,特别是使用了并行流,在cpu恰好将线程分配到多个核心的条件下(当然parallel stream 底层使用的是 JVM 的 ForkJoinPool,这东西分配线程本身就很玄学),可以达到一个很高的运行效率,然而实际普通业务一般不会有需要迭代高于10000次的计算;

- Parallel Stream 受引 CPU 环境影响很大,当没分配到多个cpu核心时,加上引用 forkJoinPool 的开销,运行效率可能还不如普通的 Stream;

使用 Stream 的建议

- 简单的迭代逻辑,可以直接使用 iterator,对于有多步处理的迭代逻辑,可以使用 stream,损失一点几乎没有的效率,换来代码的高可读性是值得的

- 单核 cpu 环境,不推荐使用 parallel stream,在多核 cpu 且有大数据量的条件下,推荐使用 paralle stream;

- stream 中含有装箱类型,在进行中间操作之前,最好转成对应的数值流,减少由于频繁的拆箱、装箱造成的性能损失;

原文地址:https://blog.csdn.net/Al_assad/article/details/82356606

JDK8 Stream 数据流效率分析的更多相关文章

  1. 大型网站技术架构(四)--核心架构要素 开启mac上印象笔记的代码块 大型网站技术架构(三)--架构模式 JDK8 stream toMap() java.lang.IllegalStateException: Duplicate key异常解决(key重复)

    大型网站技术架构(四)--核心架构要素   作者:13GitHub:https://github.com/ZHENFENG13版权声明:本文为原创文章,未经允许不得转载.此篇已收录至<大型网站技 ...

  2. Java List去重以及效率分析

    List去重无非几种方法: 下面文章提供的两种: https://blog.csdn.net/u012156163/article/details/78338574, 以及使用List.stream. ...

  3. in和exists的区别与SQL执行效率分析

    可总结为:当子查询表比主查询表大时,用Exists:当子查询表比主查询表小时,用in SQL中in可以分为三类: 1.形如select * from t1 where f1 in ('a','b'), ...

  4. mssql分页原理及效率分析

    下面是常用的分页,及其分页效率分析. 1.分页方案一:(利用Not In和SELECT TOP分页) 语句形式: SELECT TOP 10 * FROM TestTable WHERE (ID NO ...

  5. 浅谈stream数据流

    汴水流,泗水流,流到瓜州古渡头, 吴山点点愁.    我们知道水是源源不断的, 抽刀断水水更流, 斩不断, 理还乱,  是水流.(技术贴, 本文权当读者没学过古诗). 在一些语言里, 我们的前辈把数据 ...

  6. 团队工作效率分析工具gitstats

    如果你是团队领导,关心团队的开发效率和工作激情:如果你是开源软件开发者,维护者某个repo:又或者,你关心某个开源软件的开发进度,那么你可以试一试gitstats. gitstats 是一个git仓库 ...

  7. [LeetCode] 295. Find Median from Data Stream ☆☆☆☆☆(数据流中获取中位数)

    295. Find Median from Data Stream&数据流中的中位数 295. Find Median from Data Stream https://leetcode.co ...

  8. 声笔飞码GB2312单字效率分析

    -----------------------声笔飞码强字方式单字效率分析-------------------------- 2   keys: 567       items, 381900209 ...

  9. Flash和js交互的效率分析

    Flash和js交互的效率分析   AS代码: var time:int = getTimer(); for (var i:int = 0; i < 50000; i++) { External ...

随机推荐

  1. mac下解压bin文件

    在mac下要解压Android-ndk-r10e-darwin-x86_64.bin文件. 1.进入文件所在目录,修改文件的读取权限 chmod a+x android-ndk-r10e-darwin ...

  2. 订单风险系统BI

    最近被公司叫去协助传统做维表查询服务,项目已经做完.和前端联调过程发现oracle对查询 sql和产品设计还是挺重要的.不能全部堆给代码去做,如何方便代码,代码优化到最高性能才是首要解决的事,前端才能 ...

  3. C++ 静态对象

    一:什么是静态对象?     对象的存储方式是静态的.        局部静态对象和类的静态对象.      局部静态对象:一个变量在函数内部定义,其生命周期跨越了该函数的多次调用.局部对象确保不迟于 ...

  4. CSP-S模拟41影子,玫瑰花精题解

    题面:https://www.cnblogs.com/Juve/articles/11523567.html 影子: 暴力方法:枚举每一对点暴力统计最小权 优化:考虑并查集,枚举每个点,如果没有被访问 ...

  5. day 71作业

    作业: url配置 urlpatterns = [ url(r'^v2/cars/$',views.CarAPIView.as_view()), url(r'^v2/cars/(?P<pk> ...

  6. 第三章 Odoo 12 开发之创建第一个 Odoo 应用

    Odoo 开发通常都需要创建自己的插件模块.本文中我们将通过创建第一个应用来一步步学习如何在 Odoo 中开启和安装这个插件.我们将从基础的开发流学起,即创建和安装新插件,然后在开发迭代中更新代码来进 ...

  7. ajax无刷新上传文件

    网页上传文件最简单的方式就是通过表单上传了,但是在提交表单的时候会导致网页刷新,但有的时候我们不想网页刷新,有什么办法呢,我们可以使用ajax上传文件来做到这一点.只有ajax还不行,还需要JavaS ...

  8. 线程安全之suspend(挂起) 和resume(执行)

    suspend()不会释放锁 如果加锁发生在resume()之前会发生死锁 t.join()是阻塞此方法,此线程再继续:通常用于在main()主线程内,等待其它线程完成再结束main()主线程.图中j ...

  9. 2018-12-15-VisualStudio-通过-EditorBrowsable-隐藏不开放的属性或方法

    title author date CreateTime categories VisualStudio 通过 EditorBrowsable 隐藏不开放的属性或方法 lindexi 2018-12- ...

  10. 3.appium定位方法

    1.使用id定位: driver.find_element_by_id('id的名称').click() 2.使用className定位: driver.find_element_by_class_n ...