点击上方蓝字设置为星标吧～java
https://blog.csdn.net/Al_assad/article/details/82356606面试
阿面和你一块儿读：算法
正文数组
Stream 是Java SE 8类库中新增的关键抽象，它被定义于 java.util.stream （这个包里有若干流类型：Stream<T> 表明对象引用流，此外还有一系列特化流，如 IntStream，LongStream，DoubleStream等 ），Java 8 引入的的Stream主要用于取代部分Collection的操做，每一个流表明一个值序列，流提供一系列经常使用的汇集操做，能够便捷的在它上面进行各类运算。集合类库也提供了便捷的方式使咱们能够以操做流的方式使用集合、数组以及其它数据结构；微信
stream 的操做种类
中间操做数据结构
一、当数据源中的数据上了流水线后，这个过程对数据进行的全部操做都称为“中间操做”；
二、中间操做仍然会返回一个流对象，所以多个中间操做能够串连起来造成一个流水线；
三、stream 提供了多种类型的中间操做，如 filter、distinct、map、sorted 等等；app
终端操做函数
一、当全部的中间操做完成后，若要将数据从流水线上拿下来，则须要执行终端操做；oop
二、stream 对于终端操做，能够直接提供一个中间操做的结果，或者将结果转换为特定的 collection、array、String 等。性能
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：Ubuntu16.04 xenialCPU：IntelCore i7-8550URAM：16GBJDK version：1.8.0\_151JVM：HotSpot(TM) 64-BitServer VM (build 25.151-b12, mixed mode)JVM Settings:-Xms1024m-Xmx6144m-XX:MaxMetaspaceSize=512m-XX:ReservedCodeCacheSize=1024m-XX:+UseConcMarkSweepGC-XX:SoftRefLRUPolicyMSPerMB=100
一、映射处理测试
把一个随机数列（ List<Integer>）中的每个元素自增1后，从新组装为一个新的 List<Integer>，测试的随机数列容量从 10 - 10000000，跑10次取平均时间；
//streamList<Integer> result = list.stream().mapToInt(x -> x).map(x -> ++x).boxed().collect(Collectors.toCollection(ArrayList::new));//iteratorList<Integer> result = newArrayList<>();for(Integer e : list){ result.add(++e);}//parallel streamList<Integer> result = list.parallelStream().mapToInt(x -> x).map(x -> ++x).boxed()
二、过滤处理测试
取出一个随机数列（ List<Integer>）中的大于 200 的元素，并组装为一个新的 List<Integer>，测试的随机数列容量从 10 - 10000000，跑10次取平均时间；
//streamList<Integer> result = list.stream().mapToInt(x -> x).filter(x -> x > 200).boxed().collect(Collectors.toCollection(ArrayList::new));//iteratorList<Integer> result = newArrayList<>(list.size());for(Integer e : list){if(e > 200){ result.add(e);}}//parallel streamList<Integer> result = list.parallelStream().mapToInt(x -> x).filter(x -> x > 200).boxed()
三、天然排序测试
对一个随机数列（ List<Integer>）进行天然排序，并组装为一个新的 List<Integer>，iterator 使用的是 Collections # sort API（使用归并排序算法实现），测试的随机数列容量从 10 - 10000000，跑10次取平均时间。
//streamList<Integer> result = list.stream().mapToInt(x->x).sorted().boxed().collect(Collectors.toCollection(ArrayList::new));//iteratorList<Integer> result = newArrayList<>(list);Collections.sort(result);//parallel streamList<Integer> result = list.parallelStream().mapToInt(x->x).sorted().boxed()
四、归约统计测试
获取一个随机数列（ List<Integer>）的最大值，测试的随机数列容量从 10 - 10000000，跑10次取平均时间；
//streamint max = list.stream().mapToInt(x -> x).max().getAsInt();//iteratorint max = -1;for(Integer e : list){if(e > max){ max = e;}}//parallel streamint max = list.parallelStream().mapToInt(x -> x).max()
五、字符串拼接测试
获取一个随机数列（ List<Integer>）各个元素使用“,”分隔的字符串，测试的随机数列容量从 10 - 10000000，跑10次取平均时间；
//streamString result = list.stream().map(String::valueOf).collect(Collectors.joining(","));//iteratorStringBuilder builder = newStringBuilder();for(Integer e : list){ builder.append(e).append(",");}String result = builder.length() == 0? "": builder.substring(0,builder.length() - 1);//parallel stream
六、混合操做测试
对一个随机数列（ List<Integer>）进行去空值，除重，映射，过滤，并组装为一个新的 List<Integer>，测试的随机数列容量从 10 - 10000000，跑10次取平均时间；
//streamList<Integer> result = list.stream().filter(Objects::nonNull).mapToInt(x -> x + 1).filter(x -> x > 200).distinct().boxed().collect(Collectors.toCollection(ArrayList::new));//iteratorHashSet<Integer> set= newHashSet<>(list.size());for(Integer e : list){if(e != null&& e > 200){set.add(e + 1);}}List<Integer> result = newArrayList<>(set);//parallel streamList<Integer> result = list.parallelStream().filter(Objects::nonNull).mapToInt(x -> x + 1).filter(x -> x > 200).distinct().boxed()
七、实验结果总结
从以上的实验来看，能够总结处如下几点：
一、在少低数据量的处理场景中（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 中含有装箱类型，在进行中间操做以前，最好转成对应的数值流，减小因为频繁的拆箱、装箱形成的性能损失；
文章有帮助没
本文分享自微信公众号 - Java面试进化论（AuditionEvolution）。
若有侵权，请联系 support@oschina.cn 删除。
本文参与“OSC源创计划”，欢迎正在阅读的你也加入，一块儿分享。