浅谈HashMap中7种遍历方式的性能分析

目录

• 一、前言
• 二、HashMap遍历
  • 2.1、迭代器EntrySet
  • 2.2、迭代器 KeySet
  • 2.3、ForEachEntrySet
  • 2.4、ForEach KeySet
  • 2.5、Lambda
  • 2.6、Streams API 单线程
  • 2.7、Streams API 多线程
• 三、性能分析
• 四、字节码分析
• 五、EntrySet性能分析
• 六、安全性测试
  • 6.1、迭代器方式
  • 6.2、For 循环方式
  • 6.3、Lambda 方式
  • 6.4、Stream 方式
  • 6.5、小结
• 七、总结

一、前言

随着 JDK 1.8 Streams API 的发布，使得 HashMap 拥有了更多的遍历的方式，但应该选择那种遍历方式？反而成了一个问题。

本文主要内容如下图所示：

二、HashMap遍历

HashMap遍历从大的方向来说，可分为以下 4 类：

• 迭代器（Iterator）方式遍历；
• For Each 方式遍历；
• Lambda 表达式遍历（JDK 1.8+）;
• Streams API 遍历（JDK 1.8+）。

但每种类型下又有不同的实现方式，因此具体的遍历方式又可以分为以下 7 种：

• 使用迭代器（Iterator）EntrySet 的方式进行遍历；
• 使用迭代器（Iterator）KeySet 的方式进行遍历；
• 使用 For Each EntrySet 的方式进行遍历；
• 使用 For Each KeySet 的方式进行遍历；
• 使用 Lambda 表达式的方式进行遍历；
• 使用 Streams API 单线程的方式进行遍历；
• 使用 Streams API 多线程的方式进行遍历。

接下来我们来看每种遍历方式的具体实现代码。

2.1、迭代器EntrySet

1. @Test
2. public void testIterator() {
3. // 创建并赋值 HashMap
4. Map<Integer, String> map = new HashMap();
5. map.put(1, "Java");
6. map.put(2, "JDK");
7. map.put(3, "Spring Framework");
8. map.put(4, "MyBatis framework");
9. map.put(5, "Oracle Database");
10. // 遍历
11. Iterator<Map.Entry<Integer, String>> iterator = map.entrySet().iterator();
12. while (iterator.hasNext()) {
13. Map.Entry<Integer, String> entry = iterator.next();
14. System.out.println(entry.getKey() + ":" + entry.getValue());
15. }
16. }

运行结果：

2.2、迭代器 KeySet

1. @Test
2. public void testKeySet() {
3. // 创建并赋值 HashMap
4. Map<Integer, String> map = new HashMap();
5. map.put(1, "Java");
6. map.put(2, "JDK");
7. map.put(3, "Spring Framework");
8. map.put(4, "MyBatis framework");
9. map.put(5, "Test KeySet");
10. // 遍历
11. Iterator<Integer> iterator = map.keySet().iterator();
12. while (iterator.hasNext()) {
13. Integer key = iterator.next();
14. System.out.println(key + ":" + map.get(key));
15. }
16. }

运行结果：

2.3、ForEachEntrySet

1. @Test
2. public void testForEachEntrySet() {
3. // 创建并赋值 HashMap
4. Map<Integer, String> map = new HashMap();
5. map.put(1, "Java");
6. map.put(2, "JDK");
7. map.put(3, "Spring Framework");
8. map.put(4, "MyBatis framework");
9. map.put(5, "Test ForEach EntrySet");
10. // 遍历
11. for (Map.Entry<Integer, String> entry : map.entrySet()) {
12. System.out.println(entry.getKey() + ":" + entry.getValue());
13. }
14. }

运行结果：

2.4、ForEach KeySet

1. @Test
2. public void testForEachKeySet() {
3. // 创建并赋值 HashMap
4. Map<Integer, String> map = new HashMap();
5. map.put(1, "Java");
6. map.put(2, "JDK");
7. map.put(3, "Spring Framework");
8. map.put(4, "MyBatis framework");
9. map.put(5, "Test ForEach KeySet");
10. // 遍历
11. for (Integer key : map.keySet()) {
12. System.out.println(key + ":" + map.get(key));
13. }
14. }

运行结果：

2.5、Lambda

1. @Test
2. public void testLambda() {
3. // 创建并赋值 HashMap
4. Map<Integer, String> map = new HashMap();
5. map.put(1, "Java");
6. map.put(2, "JDK");
7. map.put(3, "Spring Framework");
8. map.put(4, "MyBatis framework");
9. map.put(5, "Test Lambda");
10. // 遍历
11. map.forEach((key, value) -> {
12. System.out.println(key + ":" + value);
13. });
14. }

运行结果：

2.6、Streams API 单线程

1. @Test
2. public void testStreamApi() {
3. // 创建并赋值 HashMap
4. Map<Integer, String> map = new HashMap();
5. map.put(1, "Java");
6. map.put(2, "JDK");
7. map.put(3, "Spring Framework");
8. map.put(4, "MyBatis framework");
9. map.put(5, "Test Stream API");
10. // 遍历
11. map.entrySet().stream().forEach((entry) -> {
12. System.out.println(entry.getKey() + ":" + entry.getValue());
13. });
14. }

运行结果：

2.7、Streams API 多线程

1. @Test
2. public void testParallelStreamApi() {
3. // 创建并赋值 HashMap
4. Map<Integer, String> map = new HashMap();
5. map.put(1, "Java");
6. map.put(2, "JDK");
7. map.put(3, "Spring Framework");
8. map.put(4, "MyBatis framework");
9. map.put(5, "Test Parallel Stream API");
10. // 遍历
11. map.entrySet().parallelStream().forEach((entry) -> {
12. System.out.println(entry.getKey() + ":" + entry.getValue());
13. });
14. }

运行结果：

三、性能分析

接下来我们使用 Oracle 官方提供的性能测试工具 JMH（Java Microbenchmark Harness，JAVA 微基准测试套件）来测试一下这 7 种循环的性能。

首先我们需要引入JMH框架，本次构建依赖使用工具为Gradle，引入配置如下：

implementation "org.openjdk.jmh:jmh-core:1.23"

implementation "org.openjdk.jmh:jmh-generator-annprocess:1.23"

如果使用Maven，可引入如下配置：

1. <!-- https://mvnrepository.com/artifact/org.openjdk.jmh/jmh-core -->
2. <dependency>
3. <groupId>org.openjdk.jmh</groupId>
4. <artifactId>jmh-core</artifactId>
5. <version>1.23</version>
6. </dependency>
7. <!-- https://mvnrepository.com/artifact/org.openjdk.jmh/jmh-generator-annprocess -->
8. <dependency>
9. <groupId>org.openjdk.jmh</groupId>
10. <artifactId>jmh-generator-annprocess</artifactId>
11. <version>1.23</version>
12. <scope>provided</scope>
13. </dependency>

编写性能测试代码如下：

1. //@BenchmarkMode(Mode.Throughput) // 测试类型：吞吐量
2. @BenchmarkMode(Mode.AverageTime) // 测试类型：平均消耗时间
3. //@OutputTimeUnit(TimeUnit.MILLISECONDS)
4. @OutputTimeUnit(TimeUnit.NANOSECONDS)
5. @Warmup(iterations = 4, time = 1, timeUnit = TimeUnit.SECONDS) // 预热 4 轮，每次 1s
6. @Measurement(iterations = 10, time = 3, timeUnit = TimeUnit.SECONDS) // 测试 10 轮，每次 3s
7. @Fork(1) // fork 1 个线程
8. @State(Scope.Thread) // 每个测试线程一个实例
9. public class HashMapTest {
10.  
11. static Map<Integer, String> map = new HashMap() {
12. {
13. for(int var1 = 0; var1 < 2; ++var1) {
14. this.put(var1, "Kevin:" + var1);
15. }
16.  
17. }
18. };
19.  
20. public static void main(String[] args) throws RunnerException {
21. // 启动基准测试
22. Options opt = new OptionsBuilder()
23. .include(HashMapTest.class.getSimpleName()) // 要导入的测试类
24. .output("E:/IDEAWorkSpaces/Test/src/main/java/com/kevin/performance/jmh-map2.log") // 输出测试结果的文件
25. .build();
26. new Runner(opt).run(); // 执行测试
27. }
28.  
29. /**
30. * Iterator遍历 entrySet
31. */
32. @Benchmark
33. public void entrySet() {
34. // 遍历
35. Iterator<Map.Entry<Integer, String>> iterator = map.entrySet().iterator();
36. while (iterator.hasNext()) {
37. Map.Entry<Integer, String> entry = iterator.next();
38. Integer k = entry.getKey();
39. String v = entry.getValue();
40. }
41. }
42.  
43. /**
44. * Foreach遍历 entrySet
45. */
46. @Benchmark
47. public void forEachEntrySet() {
48. // 遍历
49. for (Map.Entry<Integer, String> entry : map.entrySet()) {
50. Integer k = entry.getKey();
51. String v = entry.getValue();
52. }
53. }
54.  
55. /**
56. * Iterator遍历 keySet
57. */
58. @Benchmark
59. public void keySet() {
60. Iterator<Integer> iterator = map.keySet().iterator();
61. while (iterator.hasNext()) {
62. Integer k = iterator.next();
63. String v = map.get(k);
64. }
65. }
66.  
67. /**
68. * Foreach遍历 keySet
69. */
70. @Benchmark
71. public void forEachKeySet() {
72. for (Integer key : map.keySet()) {
73. Integer k = key;
74. String v = map.get(k);
75. }
76. }
77.  
78. /**
79. * Lambda遍历
80. */
81. @Benchmark
82. public void lambda() {
83. map.forEach((key, value) -> {
84. Integer k = key;
85. String v = value;
86. });
87. }
88.  
89. /**
90. * 单线程遍历
91. */
92. @Benchmark
93. public void streamApi() {
94. map.entrySet().stream().forEach((entry) -> {
95. Integer k = entry.getKey();
96. String v = entry.getValue();
97. });
98. }
99.  
100. /**
101. * 多线程遍历
102. */
103. public void parallelStreamApi() {
104. map.entrySet().parallelStream().forEach((entry) -> {
105. Integer k = entry.getKey();
106. String v = entry.getValue();
107. });
108. }
109. }

所有被添加了@Benchmark注解的方法都会被测试（由于 parallelStream 为多线程版本性能一定由于其他单线程，故不参与本次测试），测试结果如下：

其中 Units 为 ns/op 意思是执行完成时间（单位为纳秒），而 Score 列为平均执行时间，±符号表示误差。从以上结果可以看出，两个entrySet的性能相近，并且执行速度最快，接下来是stream，然后是两个keySet，性能最差的是KeySet。

结论：

从以上结果可以看出entrySet的性能比keySet的性能高出了一倍之多，因此我们应该尽量使用entrySet来实现 Map集合的遍历。

四、字节码分析

要理解以上的测试结果，我们需要把所有遍历代码通过javac编译成字节码来看具体的原因。

编译后，我们使用 Idea 打开字节码，内容如下：

1. public class HashMapTest {
2. static Map<Integer, String> map = new HashMap() {
3. {
4. for(int var1 = 0; var1 < 2; ++var1) {
5. this.put(var1, "Kevin:" + var1);
6. }
7. }
8. };
9.  
10. public HashMapTest() {
11. }
12.  
13. public static void main(String[] var0) {
14. entrySet();
15. keySet();
16. forEachEntrySet();
17. forEachKeySet();
18. lambda();
19. streamApi();
20. parallelStreamApi();
21. }
22.  
23. public static void entrySet() {
24. Iterator var0 = map.entrySet().iterator();
25.  
26. while(var0.hasNext()) {
27. Entry var1 = (Entry)var0.next();
28. System.out.println(var1.getKey() + ":" + (String)var1.getValue());
29. }
30. }
31.  
32. public static void keySet() {
33. Iterator var0 = map.keySet().iterator();
34.  
35. while(var0.hasNext()) {
36. Integer var1 = (Integer)var0.next();
37. System.out.println(var1 + ":" + (String)map.get(var1));
38. }
39. }
40.  
41. public static void forEachEntrySet() {
42. Iterator var0 = map.entrySet().iterator();
43.  
44. while(var0.hasNext()) {
45. Entry var1 = (Entry)var0.next();
46. System.out.println(var1.getKey() + ":" + (String)var1.getValue());
47. }
48. }
49.  
50. public static void forEachKeySet() {
51. Iterator var0 = map.keySet().iterator();
52.  
53. while(var0.hasNext()) {
54. Integer var1 = (Integer)var0.next();
55. System.out.println(var1 + ":" + (String)map.get(var1));
56. }
57. }
58.  
59. public static void lambda() {
60. map.forEach((var0, var1) -> {
61. System.out.println(var0 + ":" + var1);
62. });
63. }
64.  
65. public static void streamApi() {
66. map.entrySet().stream().forEach((var0) -> {
67. System.out.println(var0.getKey() + ":" + (String)var0.getValue());
68. });
69. }
70.  
71. public static void parallelStreamApi() {
72. map.entrySet().parallelStream().forEach((var0) -> {
73. System.out.println(var0.getKey() + ":" + (String)var0.getValue());
74. });
75. }
76. }
77.  
78. //从结果可以看出，除了 Lambda 和 Streams API 之外，通过迭代器循环和 for 循环的遍历的 EntrySet 最终生成的代码是一样的，他们都是在循环中创建了一个遍历对象 Entry ，代码如下：
79.  
80. public static void entrySet() {
81. Iterator var0 = map.entrySet().iterator();
82. while(var0.hasNext()) {
83. Entry var1 = (Entry)var0.next();
84. System.out.println(var1.getKey() + ":" + (String)var1.getValue());
85. }
86. }
87. public static void forEachEntrySet() {
88. Iterator var0 = map.entrySet().iterator();
89. while(var0.hasNext()) {
90. Entry var1 = (Entry)var0.next();
91. System.out.println(var1.getKey() + ":" + (String)var1.getValue());
92. }
93. }
94. //而 KeySet 的代码也是类似的，如下所示：
95.  
96. public static void keySet() {
97. Iterator var0 = map.keySet().iterator();
98. while(var0.hasNext()) {
99. Integer var1 = (Integer)var0.next();
100. System.out.println(var1 + ":" + (String)map.get(var1));
101. }
102. }
103. public static void forEachKeySet() {
104. Iterator var0 = map.keySet().iterator();
105. while(var0.hasNext()) {
106. Integer var1 = (Integer)var0.next();
107. System.out.println(var1 + ":" + (String)map.get(var1));
108. }
109. }

从结果可以看出，除了 Lambda 和 Streams API 之外，通过迭代器循环和for循环的遍历的EntrySet最终生成的代码是一样的，他们都是在循环中创建了一个遍历对象Entry，代码如下：

1. public static void entrySet() {
2. Iterator var0 = map.entrySet().iterator();
3. while(var0.hasNext()) {
4. Entry var1 = (Entry)var0.next();
5. System.out.println(var1.getKey() + ":" + (String)var1.getValue());
6. }
7. }
8. public static void forEachEntrySet() {
9. Iterator var0 = map.entrySet().iterator();
10. while(var0.hasNext()) {
11. Entry var1 = (Entry)var0.next();
12. System.out.println(var1.getKey() + ":" + (String)var1.getValue());
13. }
14. }

而KeySet的代码也是类似的，如下所示：

1. public static void keySet() {
2. Iterator var0 = map.keySet().iterator();
3. while(var0.hasNext()) {
4. Integer var1 = (Integer)var0.next();
5. System.out.println(var1 + ":" + (String)map.get(var1));
6. }
7. }
8. public static void forEachKeySet() {
9. Iterator var0 = map.keySet().iterator();
10. while(var0.hasNext()) {
11. Integer var1 = (Integer)var0.next();
12. System.out.println(var1 + ":" + (String)map.get(var1));
13. }
14. }

所以我们在使用迭代器或是for循环EntrySet时，他们的性能都是相同的，因为他们最终生成的字节码基本都是一样的；同理KeySet的两种遍历方式也是类似的。

五、EntrySet性能分析

EntrySet之所以比KeySet的性能高是因为，KeySet在循环时使用了map.get(key)，而map.get(key)相当于又遍历了一遍 Map 集合去查询key所对应的值。为什么要用“又”这个词？那是因为在使用迭代器或者 for 循环时，其实已经遍历了一遍 Map 集合了，因此再使用map.get(key)查询时，相当于遍历了两遍。

而EntrySet只遍历了一遍 Map 集合，之后通过代码“Entry<Integer, String> entry = iterator.next()”把对象的key和value值都放入到了Entry对象中，因此再获取key和value值时就无需再遍历 Map 集合，只需要从Entry对象中取值就可以了。

所以，EntrySet的性能比KeySet的性能高出了一倍，因为KeySet相当于循环了两遍 Map 集合，而EntrySet只循环了一遍。

六、安全性测试

从上面的性能测试结果和原理分析，我想大家应该选用那种遍历方式，已经心中有数的，而接下来我们就从「安全」的角度入手，来分析那种遍历方式更安全。

我们把以上遍历划分为四类进行测试：迭代器方式、For 循环方式、Lambda 方式和 Stream 方式，测试代码如下。

6.1、迭代器方式

1. Iterator<Map.Entry<Integer, String>> iterator = map.entrySet().iterator();
2. while (iterator.hasNext()) {
3. Map.Entry<Integer, String> entry = iterator.next();
4. if (entry.getKey() == 1) {
5. // 删除
6. System.out.println("del:" + entry.getKey());
7. iterator.remove();
8. } else {
9. System.out.println("show:" + entry.getKey());
10. }
11. }

运行结果：

show:0

del:1

show:2

测试结果：迭代器中循环删除数据安全。

6.2、For 循环方式

1. for (Map.Entry<Integer, String> entry : map.entrySet()) {
2. if (entry.getKey() == 1) {
3. // 删除
4. System.out.println("del:" + entry.getKey());
5. map.remove(entry.getKey());
6. } else {
7. System.out.println("show:" + entry.getKey());
8. }
9. }

运行结果：

测试结果：For 循环中删除数据非安全。

6.3、Lambda 方式

1. map.forEach((key, value) -> {
2. if (key == 1) {
3. System.out.println("del:" + key);
4. map.remove(key);
5. } else {
6. System.out.println("show:" + key);
7. }
8. });

运行结果：

测试结果：Lambda 循环中删除数据非安全。

Lambda 删除的正确方式：

1. // 根据 map 中的 key 去判断删除
2. map.keySet().removeIf(key -> key == 1);
3. map.forEach((key, value) -> {
4. System.out.println("show:" + key);
5. });

运行结果：

show:0

show:2

从上面的代码可以看出，可以先使用Lambda的removeIf删除多余的数据，再进行循环是一种正确操作集合的方式。

6.4、Stream 方式

1. map.entrySet().stream().forEach((entry) -> {
2. if (entry.getKey() == 1) {
3. System.out.println("del:" + entry.getKey());
4. map.remove(entry.getKey());
5. } else {
6. System.out.println("show:" + entry.getKey());
7. }
8. });

运行结果：

测试结果：Stream 循环中删除数据非安全。

Stream 循环的正确方式：

1. map.entrySet().stream().filter(m -> 1 != m.getKey()).forEach((entry) -> {
2. if (entry.getKey() == 1) {
3. System.out.println("del:" + entry.getKey());
4. } else {
5. System.out.println("show:" + entry.getKey());
6. }
7. });

运行结果：

show:0

show:2

从上面的代码可以看出，可以使用Stream中的filter过滤掉无用的数据，再进行遍历也是一种安全的操作集合的方式。

6.5、小结

我们不能在遍历中使用集合map.remove()来删除数据，这是非安全的操作方式，但我们可以使用迭代器的iterator.remove()的方法来删除数据，这是安全的删除集合的方式。同样的我们也可以使用 Lambda 中的removeIf来提前删除数据，或者是使用 Stream 中的filter过滤掉要删除的数据进行循环，这样都是安全的，当然我们也可以在for循环前删除数据在遍历也是线程安全的。

七、总结

本文我们讲了 HashMap 4 种遍历方式：迭代器、for、lambda、stream，以及具体的 7 种遍历方法，综合性能和安全性来看，我们应该尽量使用迭代器（Iterator）来遍历EntrySet的遍历方式来操作 Map 集合，这样就会既安全又高效了。

以上就是浅谈HashMap中7种遍历方式的性能分析的详细内容，更多关于HashMap 遍历性能分析的资料请关注服务器之家其它相关文章！

原文链接：https://www.cnblogs.com/Kevin-ZhangCG/p/14931992.html