你了解JDK8Stream数据流效率吗？千万级数据量性能如何？

>>号外&＃xff1a;关注“Java精选”公众号&＃xff0c;回复“2021面试题”&＃xff0c;领取免费资料&＃xff01;“Java精选面试题”小程序&＃xff0c;3000&＃43; 道面试题在线刷&＃xff0c;最新、最全 Java 面试题&＃xff01;

Stream 是Java SE 8类库中新增的关键抽象&＃xff0c;它被定义于 java.util.stream &＃xff08;这个包里有若干流类型&＃xff1a;Stream 代表对象引用流&＃xff0c;此外还有一系列特化流&＃xff0c;如 IntStream&＃xff0c;LongStream&＃xff0c;DoubleStream等。

Java 8 引入的的Stream主要用于取代部分Collection的操作&＃xff0c;每个流代表一个值序列&＃xff0c;流提供一系列常用的聚集操作&＃xff0c;可以便捷的在它上面进行各种运算。集合类库也提供了便捷的方式使我们可以以操作流的方式使用集合、数组以及其它数据结构&＃xff1b;

stream 的操作种类

①中间操作

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

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

• stream 提供了多种类型的中间操作&＃xff0c;如 filter、distinct、map、sorted 等等&＃xff1b;

②终端操作

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

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

stream 的特点

①只能遍历一次&＃xff1a;

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

②采用内部迭代的方式&＃xff1a;

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

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

stream 相对于 Collection 的优点

• 无存储&＃xff1a; 流并不存储值&＃xff1b;流的元素源自数据源&＃xff08;可能是某个数据结构、生成函数或I/O通道等等&＃xff09;&＃xff0c;通过一系列计算步骤得到&＃xff1b;

• 函数式风格&＃xff1a; 对流的操作会产生一个结果&＃xff0c;但流的数据源不会被修改&＃xff1b;

• 惰性求值&＃xff1a; 多数流操作&＃xff08;包括过滤、映射、排序以及去重&＃xff09;都可以以惰性方式实现。这使得我们可以用一遍遍历完成整个流水线操作&＃xff0c;并可以用短路操作提供更高效的实现&＃xff1b;

• 无需上界&＃xff1a; 不少问题都可以被表达为无限流&＃xff08;infinite stream&＃xff09;&＃xff1a;用户不停地读取流直到满意的结果出现为止&＃xff08;比如说&＃xff0c;枚举 完美数 这个操作可以被表达为在所有整数上进行过滤&＃xff09;&＃xff1b;集合是有限的&＃xff0c;但流可以表达为无线流&＃xff1b;

• 代码简练&＃xff1a; 对于一些collection的迭代处理操作&＃xff0c;使用 stream 编写可以十分简洁&＃xff0c;如果使用传统的 collection 迭代操作&＃xff0c;代码可能十分啰嗦&＃xff0c;可读性也会比较糟糕&＃xff1b;

stream 和 iterator 迭代的效率比较

先说结论&＃xff1a;

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

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

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

测试环境如下&＃xff1a;

System&＃xff1a;Ubuntu 16.04 xenialCPU&＃xff1a;Intel Core i7-8550URAM&＃xff1a;16GBJDK version&＃xff1a;1.8.0_151JVM&＃xff1a;HotSpot(TM) 64-Bit Server VM (build 25.151-b12, mixed mode)JVM Settings:-Xms1024m-Xmx6144m-XX:MaxMetaspaceSize&＃61;512m-XX:ReservedCodeCacheSize&＃61;1024m-XX:&＃43;UseConcMarkSweepGC-XX:SoftRefLRUPolicyMSPerMB&＃61;100


1. 映射处理测试

把一个随机数列&＃xff08;List&＃xff09;中的每一个元素自增1后&＃xff0c;重新组装为一个新的 List&＃xff0c;测试的随机数列容量从 10 - 10000000&＃xff0c;跑10次取平均时间&＃xff1b;

//stream
List result &＃61; list.stream()
.mapToInt(x -> x)
.map(x -> &＃43;&＃43;x)
.boxed()
.collect(Collectors.toCollection(ArrayList::new));
//iterator
List result &＃61; new ArrayList<>();
for(Integer e : list){result.add(&＃43;&＃43;e);
}
//parallel stream
List result &＃61; list.parallelStream()
.mapToInt(x -> x)
.map(x -> &＃43;&＃43;x)
.boxed()
.collect(Collectors.toCollection(ArrayList::new));


2. 过滤处理测试

取出一个随机数列&＃xff08;List&＃xff09;中的大于 200 的元素&＃xff0c;并组装为一个新的 List&＃xff0c;测试的随机数列容量从 10 - 10000000&＃xff0c;跑10次取平均时间&＃xff1b;

//stream
List result &＃61; list.stream()
.mapToInt(x -> x)
.filter(x -> x > 200)
.boxed()
.collect(Collectors.toCollection(ArrayList::new));
//iterator
List result &＃61; new ArrayList<>(list.size());
for(Integer e : list){if(e > 200){result.add(e);}
}
//parallel stream
List result &＃61; list.parallelStream()
.mapToInt(x -> x)
.filter(x -> x > 200)
.boxed()
.collect(Collectors.toCollection(ArrayList::new));


3. 自然排序测试

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

//stream
List result &＃61; list.stream()
.mapToInt(x->x)
.sorted()
.boxed()
.collect(Collectors.toCollection(ArrayList::new));
//iterator
List result &＃61; new ArrayList<>(list);
Collections.sort(result);
//parallel stream
List result &＃61; list.parallelStream()
.mapToInt(x->x)
.sorted()
.boxed()
.collect(Collectors.toCollection(ArrayList::new));


4. 归约统计测试

获取一个随机数列&＃xff08;List&＃xff09;的最大值&＃xff0c;测试的随机数列容量从 10 - 10000000&＃xff0c;跑10次取平均时间&＃xff1b;

//stream
int max &＃61; list.stream()
.mapToInt(x -> x)
.max()
.getAsInt();
//iterator
int max &＃61; -1;
for(Integer e : list){if(e > max){max &＃61; e;}
}
//parallel stream
int max &＃61; list.parallelStream()
.mapToInt(x -> x)
.max()
.getAsInt();


5. 字符串拼接测试

获取一个随机数列&＃xff08;List&＃xff09;各个元素使用“,”分隔的字符串&＃xff0c;测试的随机数列容量从 10 - 10000000&＃xff0c;跑10次取平均时间&＃xff1b;

  //stream
String result &＃61; list.stream().map(String::valueOf).collect(Collectors.joining(","));
//iterator
StringBuilder builder &＃61; new StringBuilder();
for(Integer e : list){builder.append(e).append(",");
}
String result &＃61; builder.length() &＃61;&＃61; 0 ? "" : builder.substring(0,builder.length() - 1);
//parallel stream
String result &＃61; list.stream().map(String::valueOf).collect(Collectors.joining(","));


6. 混合操作测试

对一个随机数列&＃xff08;List&＃xff09;进行去空值&＃xff0c;除重&＃xff0c;映射&＃xff0c;过滤&＃xff0c;并组装为一个新的 List&＃xff0c;测试的随机数列容量从 10 - 10000000&＃xff0c;跑10次取平均时间&＃xff1b;

//stream
List result &＃61; list.stream()
.filter(Objects::nonNull)
.mapToInt(x -> x &＃43; 1)
.filter(x -> x > 200)
.distinct()
.boxed()
.collect(Collectors.toCollection(ArrayList::new));
//iterator
HashSet set  &＃61; new HashSet<>(list.size());
for(Integer e : list){if(e !&＃61; null && e > 200){set.add(e &＃43; 1);}
}
List result &＃61; new ArrayList<>(set);
//parallel stream
List result &＃61; list.parallelStream()
.filter(Objects::nonNull)
.mapToInt(x -> x &＃43; 1)
.filter(x -> x > 200)
.distinct()
.boxed()
.collect(Collectors.toCollection(ArrayList::new));


实验结果总结

从以上的实验来看&＃xff0c;可以总结处以下几点&＃xff1a;

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

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

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

使用 Stream 的建议

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

• 单核 cpu 环境&＃xff0c;不推荐使用 parallel stream&＃xff0c;在多核 cpu 且有大数据量的条件下&＃xff0c;推荐使用 paralle stream&＃xff1b;

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

作者&＃xff1a;Al_assad

blog.csdn.net/Al_assad/article/details/82356606

往期精选  点击标题可跳转

Spring 中毒太深&＃xff0c;离开 Spring 居然连最基本的接口都不会写了&＃xff01;

Spring Boot 线程池的使用心得&＃xff0c;你真会用吗&＃xff1f;

从原理到实践彻底搞懂 Java 日志系统&＃xff0c;再也不迷茫了&＃xff01;

如何设计 QQ、微信、微博、Github 等第三方账号登陆 &＃xff1f;&＃xff08;附表设计&＃xff09;

【源码解读】JDK1.8 中 ConcurrentHashMap 不支持空键值对源码剖析

为什么要代码重构&＃xff1f;如何重构&＃xff1f;常见重构技巧&＃xff0c;值得收藏&＃xff01;

面试官问&＃xff1a;为什么 Java 线程没有 Running 状态&＃xff1f;一下被问懵&＃xff01;

SpringBoot &＃43; Mybatis &＃43; Druid &＃43; PageHelper 实现多数据源并分页&＃xff08;附源码&＃xff09;

Intellij IDEA 中的各种调试代码技巧&＃xff0c;轻松定位 Bug 问题&＃xff08;涵盖超全面&＃xff09;

MyBatis 真坑&＃xff01;Integer 类型赋值 0 &＃xff0c;当 !&＃61; &＃39;&＃39; 时无法通过判断执行 SQL 语句

面试官问&＃xff1a;Spring Boot 中实现通用 Auth 认证&＃xff0c;有哪几种方式&＃xff1f;

点个赞&＃xff0c;就知道你“在看”&＃xff01;