Java8 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 等；

  
  

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次与均匀工夫；

//stream
List<Integer> result = list.stream()
.mapToInt(x -> x)
.map(x -> ++x)
.boxed()
.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次与均匀工夫；

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

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次与均匀工夫；

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

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 中露有拆箱范例，正在停止中心操纵之前，最好转成洞喀的数址索，削减因为频仍的拆箱、拆箱酿成的机能丧失；