JDK8Stream效率如何 [复制链接]

Stream是JavaSE8类库中新增的关键抽象，它被定义于java.util.stream（这个包里有若干流类型：StreamT代表对象引用流，此外还有一系列特化流，如IntStream，LongStream，DoubleStream等）。

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

stream的操作种类

①中间操作

当数据源中的数据上了流水线后，这个过程对数据进行的所有操作都称为“中间操作”；中间操作仍然会返回一个流对象，因此多个中间操作可以串连起来形成一个流水线；stream提供了多种类型的中间操作，如filter、distinct、map、sorted等等；

②终端操作

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

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

这一部分详细的说明可以参见：JDK8Stream详细使用

stream的特点

①只能遍历一次：

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

②采用内部迭代的方式：

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

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

stream相对于Collection的优点

无存储：

流并不存储值；

流的元素源自数据源（可能是某个数据结构、生成函数或I/O通道等等），通过一系列计算步骤得到；

函数式风格：

对流的操作会产生一个结果，但流的数据源不会被修改；

惰性求值：

多数流操作（包括过滤、映射、排序以及去重）都可以以惰性方式实现。

这使得我们可以用一遍遍历完成整个流水线操作，并可以用短路操作提供更高效的实现；

无需上界：

不少问题都可以被表达为无限流（infinitestream）：

用户不停地读取流直到满意的结果出现为止（比如说，枚举完美数这个操作可以被表达为在所有整数上进行过滤）；

集合是有限的，但流可以表达为无线流；

代码简练：

对于一些collection的迭代处理操作，使用stream编写可以十分简洁，如果使用传统的collection迭代操作，代码可能十分啰嗦，可读性也会比较糟糕；

stream和iterator迭代的效率比较

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

先说结论：

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

在多核情景下，对于大数据量的处理，parallelstream可以有比iterator更高的迭代处理效率；

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

测试环境如下：

System：Ubuntu16.04xenialCPU：IntelCorei7-URAM：16GBJDKversion：1.8.0_JVM：HotSpot(TM)64-BitServerVM(build25.-b12,mixedmode)JVMSettings:-Xmsm-Xmxm-XX:MaxMetaspaceSize=m-XX:ReservedCodeCacheSize=m-XXUseConcMarkSweepGC-XX:SoftRefLRUPolicyMSPerMB=

1.映射处理测试

把一个随机数列（ListInteger）中的每一个元素自增1后，重新组装为一个新的ListInteger，测试的随机数列容量从10-，跑10次取平均时间；

//streamListIntegerresult=list.stream().mapToInt(x-x).map(x-++x).boxed().collect(Collectors.toCollection(ArrayList::new));//iteratorListIntegerresult=newArrayList();for(Integerest){result.add(++e);}//parallelstreamListIntegerresult=list.parallelStream().mapToInt(x-x).map(x-++x).boxed().collect(Collectors.toCollection(ArrayList::new));

2.过滤处理测试

取出一个随机数列（ListInteger）中的大于的元素，并组装为一个新的ListInteger，测试的随机数列容量从10-，跑10次取平均时间；

//streamListIntegerresult=list.stream().mapToInt(x-x).filter(x-x).boxed().collect(Collectors.toCollection(ArrayList::new));//iteratorListIntegerresult=newArrayList(list.size());for(Integerest){if(e){result.add(e);}}//parallelstreamListIntegerresult=list.parallelStream().mapToInt(x-x).filter(x-x).boxed().collect(Collectors.toCollection(ArrayList::new));

3.自然排序测试

对一个随机数列（ListInteger）进行自然排序，并组装为一个新的ListInteger，iterator使用的是Collections#sortAPI（使用归并排序算法实现），测试的随机数列容量从10-，跑10次取平均时间；

//streamListIntegerresult=list.stream().mapToInt(x-x).sorted().boxed().collect(Collectors.toCollection(ArrayList::new));//iteratorListIntegerresult=newArrayList(list);Collections.sort(result);//parallelstreamListIntegerresult=list.parallelStream().mapToInt(x-x).sorted().boxed().collect(Collectors.toCollection(ArrayList::new));

4.归约统计测试

获取一个随机数列（ListInteger）的最大值，测试的随机数列容量从10-，跑10次取平均时间；

//streamintmax=list.stream().mapToInt(x-x).max().getAsInt();//iteratorintmax=-1;for(Integerest){if(emax){max=e;}}//parallelstreamintmax=list.parallelStream().mapToInt(x-x).max().getAsInt();

5.字符串拼接测试

获取一个随机数列（ListInteger）各个元素使用“,”分隔的字符串，测试的随机数列容量从10-，跑10次取平均时间；

//streamStringresult=list.stream().map(String::valueOf).collect(Collectors.joining(,));//iteratorStringBuilderbuilder=newStringBuilder();for(Integerest){builder.append(e).append(,);}Stringresult=builder.length()==0?:builder.substring(0,builder.length()-1);//parallelstreamStringresult=list.stream().map(String::valueOf).collect(Collectors.joining(,));

6.混合操作测试

对一个随机数列（ListInteger）进行去空值，除重，映射，过滤，并组装为一个新的ListInteger，测试的随机数列容量从10-，跑10次取平均时间；

//streamListIntegerresult=list.stream().filter(Objects::nonNull).mapToInt(x-x+1).filter(x-x).distinct().boxed().collect(Collectors.toCollection(ArrayList::new));//iteratorHashSetIntegerset=newHashSet(list.size());for(Integerest){if(e!=nulle){set.add(e+1);}}ListIntegerresult=newArrayList(set);//parallelstreamListIntegerresult=list.parallelStream().filter(Objects::nonNull).mapToInt(x-x+1).filter(x-x).distinct().boxed().collect(Collectors.toCollection(ArrayList::new));

实验结果总结

从以上的实验来看，可以总结处以下几点：

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

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

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

使用Stream的建议

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

单核cpu环境，不推荐使用parallelstream，在多核cpu且有大数据量的条件下，推荐使用parallestream；

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