Java List循环一般写法与stream性能对比

103 阅读 0 评论 68 点赞

我是靠谱客的博主秀丽香氛，这篇文章主要介绍Java List循环一般写法与stream性能对比，现在分享给大家，希望可以做个参考。

如果需要对一个List进行循环，stream出来以后，我们又多了一种实现方式。但stream方式性能如何，各种说法都有，总体结论是没有一个标准答案，受各种环境影响。耳听为虚眼见为实，我们还是要自己动手试一下，才能有一个直观的感受，先直接上代码。

复制代码

int size = 10;
// 为了防止读一个list读性能影响，各自读一个list
List<Integer> list1 = new ArrayList<>(size);
List<Integer> list2 = new ArrayList<>(size);
List<Integer> list3 = new ArrayList<>(size);
List<Integer> list4 = new ArrayList<>(size);
List<Integer> list5 = new ArrayList<>(size);
List<Integer> list6 = new ArrayList<>(size);
for(int i = 0; i < size; i++) {
list1.add(i);
list2.add(i);
list3.add(i);
list4.add(i);
list5.add(i);
list6.add(i);
}
// 用线程池来执行
ExecutorService executorService = Executors.newFixedThreadPool(6);
executorService.submit(()->{
long t = System.nanoTime();
List<String> result = new ArrayList<>(size);
for (int i = 0; i <list2.size(); i++) {
result.add(list2.get(i).toString());
}
System.out.println("for i i++ for time:
"+ (System.nanoTime()-t));
});
executorService.submit(()->{
long t = System.nanoTime();
List<String> result = new ArrayList<>(size);
for(Integer i : list3){
result.add(i.toString());
}
System.out.println("for i:list time:
" + (System.nanoTime()-t));
});
executorService.submit(()->{
long t = System.nanoTime();
List<String> result = new ArrayList<>(size);
list4.forEach(i->{
result.add(i.toString());
});
System.out.println("forEach time:
" + (System.nanoTime()-t));
});
executorService.submit(()->{
long t = System.nanoTime();
List<String> result = new ArrayList<>(size);
list5.stream().forEach(i->{
result.add(i.toString());
});
System.out.println("stream forEach time:
" + (System.nanoTime()-t));
});
executorService.submit(()->{
long t = System.nanoTime();
List<String> result = new ArrayList<>(size);
Iterator<Integer> iterator = list6.iterator();
while (iterator.hasNext()){
result.add(iterator.next().toString());
}
System.out.println("Iterator time:
" + (System.nanoTime()-t));
});
executorService.submit(()->{
long t = System.nanoTime();
List<String> result = new ArrayList<>(size);
list1.stream().parallel().forEach(i->{
result.add(i.toString());
});
System.out.println("stream parallel time:
" + (System.nanoTime()-t));
});
executorService.shutdown();

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76

int size = 10;
// 为了防止读一个list读性能影响，各自读一个list
List<Integer> list1 = new ArrayList<>(size);
List<Integer> list2 = new ArrayList<>(size);
List<Integer> list3 = new ArrayList<>(size);
List<Integer> list4 = new ArrayList<>(size);
List<Integer> list5 = new ArrayList<>(size);
List<Integer> list6 = new ArrayList<>(size);
for(int i = 0; i < size; i++) {
list1.add(i);
list2.add(i);
list3.add(i);
list4.add(i);
list5.add(i);
list6.add(i);
}
// 用线程池来执行
ExecutorService executorService = Executors.newFixedThreadPool(6);
executorService.submit(()->{
long t = System.nanoTime();
List<String> result = new ArrayList<>(size);
for (int i = 0; i <list2.size(); i++) {
result.add(list2.get(i).toString());
}
System.out.println("for i i++ for time:
"+ (System.nanoTime()-t));
});
executorService.submit(()->{
long t = System.nanoTime();
List<String> result = new ArrayList<>(size);
for(Integer i : list3){
result.add(i.toString());
}
System.out.println("for i:list time:
" + (System.nanoTime()-t));
});
executorService.submit(()->{
long t = System.nanoTime();
List<String> result = new ArrayList<>(size);
list4.forEach(i->{
result.add(i.toString());
});
System.out.println("forEach time:
" + (System.nanoTime()-t));
});
executorService.submit(()->{
long t = System.nanoTime();
List<String> result = new ArrayList<>(size);
list5.stream().forEach(i->{
result.add(i.toString());
});
System.out.println("stream forEach time:
" + (System.nanoTime()-t));
});
executorService.submit(()->{
long t = System.nanoTime();
List<String> result = new ArrayList<>(size);
Iterator<Integer> iterator = list6.iterator();
while (iterator.hasNext()){
result.add(iterator.next().toString());
}
System.out.println("Iterator time:
" + (System.nanoTime()-t));
});
executorService.submit(()->{
long t = System.nanoTime();
List<String> result = new ArrayList<>(size);
list1.stream().parallel().forEach(i->{
result.add(i.toString());
});
System.out.println("stream parallel time:
" + (System.nanoTime()-t));
});
executorService.shutdown();

size=10时间

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
for i i++ for time:
87970
for i:list time:
89757
forEach time:
793869
Iterator time:
39434
stream forEach time:
2642666
stream parallel time:
5155739

size=100时间

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
for i i++ for time:
139793
for i:list time:
182722
forEach time:
893761
Iterator time:
184108
stream forEach time:
2585223
stream parallel time:
5255004

size=10000(1W)时间

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
for i i++ for time:
7956023
forEach time:
7671925
for i:list time:
8603284
Iterator time:
7251862
stream forEach time:
8667274
stream parallel time:
13332119

size=1000000(100W)时间

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
stream parallel time:
1777977752
for i:list time:
2896940689
forEach time:
2805157215
for i i++ for time:
2905048826
stream forEach time:
2807564613
Iterator time:
2810214441

size=5000000(500W)时间

复制代码

1
2
3
4
5
6
7
8
9
10
11
12
13
stream parallel time:
3886700727
forEach time:
11432122944
for i:list time:
11443952632
for i i++ for time:
12148542655
Iterator time:
12156133873
stream forEach time:
12165886174

基本结论：从上面数据得出结论是数据量对性能评价影响较大，数据量无排序要求时推荐用stream parrellel，数据量比较小（100W以下），一般业务场景下，还是老老实实用普通写法吧，毕竟这么多年的优化，基本写法效率还是很高的。