Java8 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?>?2
.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));
评论