一、简介

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

Java 8引入的的Stream主要用于取代部分Collection的操作，每个流代表一个值序列，流提供一系列常用的聚集操作，可以便捷的在它上面进行各种运算。

集合类库也提供了便捷的方式使我们可以以操作流的方式使用集合、数组以及其它数据结构；

二、Stream 特点

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

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

ordersList.stream()
        .filter(r -> r != null)
        .collect(Collectors.groupingBy(AiOrders::getOrderID))
        .entrySet()
        .iterator()
        .forEachRemaining(r -> {
            // r.getkey 分组的key  r.getValue分组后的List值
            if (r != null && CollectionUtils.isNotEmpty(r.getValue())) {
                // 业务逻辑处理
            }
        });

三、stream相对于Collection的优点

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

四、Stream 和 Iterator效率对比

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

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

我分别对一个随机数列List（数量从10到10000000）进行映射、过滤、排序、规约统计、字符串转化场景下，对使用stream和 iterator实现的运行效率进行了统计10次取平均值。

【1】映射处理测试代码：

//stream
List<Integer> result = list.stream()
.mapToInt(x -> x) //转成IntStream
.map(x -> ++x)
.boxed() //转成Stream<Integer>
.collect(Collectors.toCollection(ArrayList::new));
//iterator
List<Integer> result = new ArrayList<>();
for(Integer e : list){
    result.add(++e);
}
//parallel stream
List<Integer> result = list.parallelStream()
.mapToInt(x -> x)
.map(x -> ++x)
.boxed()
.collect(Collectors.toCollection(ArrayList::new));

【2】过滤处理测试： 取出一个随机数列List<Integer>中的大于200的元素，并组装为一个新的List<Integer>，测试的随机数列容量从 10-10000000，跑10次取平均时间；

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

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

【4】归约统计测试： 获取一个随机数列List<Integer>的最大值，测试的随机数列容量从10-10000000，跑10次取平均时间；

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

【5】字符串拼接测试： 获取一个随机数列List<Integer>各个元素使用“,”分隔的字符串，测试的随机数列容量从10-10000000，跑10次取平均时间；

【6】混合操作测试： 对一个随机数列List<Integer>进行去空值，除重，映射，过滤，并组装为一个新的List<Integer>，测试的随机数列容量从10-10000000，跑10次取平均时间；

//stream
List<Integer> result = list.stream()
.filter(Objects::nonNull)
.mapToInt(x -> x + 1)
.filter(x -> x > 200)
.distinct()
.boxed()
.collect(Collectors.toCollection(ArrayList::new));
//iterator
HashSet<Integer> set  = new HashSet<>(list.size());
for(Integer e : list){
    if(e != null && e > 200){
        set.add(e + 1);
    }
}
List<Integer> result = new ArrayList<>(set);
//parallel stream
List<Integer> result = list.parallelStream()
.filter(Objects::nonNull)
.mapToInt(x -> x + 1)
.filter(x -> x > 200)
.distinct()
.boxed()
.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中含有装箱类型，在进行中间操作之前，最好转成对应的数值流，减少由于频繁的拆箱、装箱造成的性能损失；

(adsbygoogle = window.adsbygoogle || []).push({});