這是我的第 56 篇原創文章
隨着 JDK 1.8 Streams API 的發佈，使得 HashMap 擁有了更多的遍歷的方式，但應該選擇那種遍歷方式？反而成了一個問題。
本文先從 HashMap 的遍歷方法講起，然後再從性能、原理以及安全性等方面，來分析 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 多線程的方式進行遍歷。
接下來我們來看每種遍歷方式的具體實現代碼。
1.迭代器 EntrySet
public class HashMapTest {
public static void main(String[] args) {
// 創建並賦值 HashMap
Map<Integer, String> map = new HashMap();
map.put(1, "Java");
map.put(2, "JDK");
map.put(3, "Spring Framework");
map.put(4, "MyBatis framework");
map.put(5, "Java中文社羣");
// 遍歷
Iterator<Map.Entry<Integer, String>> iterator = map.entrySet().iterator();
while (iterator.hasNext()) {
Map.Entry<Integer, String> entry = iterator.next();
System.out.print(entry.getKey());
System.out.print(entry.getValue());
}
}
}
以上程序的執行結果爲：
1 Java 2 JDK 3 Spring Framework 4 MyBatis framework 5 Java中文社羣
2.迭代器 KeySet
public class HashMapTest {
public static void main(String[] args) {
// 創建並賦值 HashMap
Map<Integer, String> map = new HashMap();
map.put(1, "Java");
map.put(2, "JDK");
map.put(3, "Spring Framework");
map.put(4, "MyBatis framework");
map.put(5, "Java中文社羣");
// 遍歷
Iterator<Integer> iterator = map.keySet().iterator();
while (iterator.hasNext()) {
Integer key = iterator.next();
System.out.print(key);
System.out.print(map.get(key));
}
}
}
以上程序的執行結果爲：
1 Java 2 JDK 3 Spring Framework 4 MyBatis framework 5 Java中文社羣
3.ForEach EntrySet
public class HashMapTest {
public static void main(String[] args) {
// 創建並賦值 HashMap
Map<Integer, String> map = new HashMap();
map.put(1, "Java");
map.put(2, "JDK");
map.put(3, "Spring Framework");
map.put(4, "MyBatis framework");
map.put(5, "Java中文社羣");
// 遍歷
for (Map.Entry<Integer, String> entry : map.entrySet()) {
System.out.print(entry.getKey());
System.out.print(entry.getValue());
}
}
}
以上程序的執行結果爲：
1 Java 2 JDK 3 Spring Framework 4 MyBatis framework 5 Java中文社羣
4.ForEach KeySet
public class HashMapTest {
public static void main(String[] args) {
// 創建並賦值 HashMap
Map<Integer, String> map = new HashMap();
map.put(1, "Java");
map.put(2, "JDK");
map.put(3, "Spring Framework");
map.put(4, "MyBatis framework");
map.put(5, "Java中文社羣");
// 遍歷
for (Integer key : map.keySet()) {
System.out.print(key);
System.out.print(map.get(key));
}
}
}
以上程序的執行結果爲：
1 Java 2 JDK 3 Spring Framework 4 MyBatis framework 5 Java中文社羣
5.Lambda
public class HashMapTest {
public static void main(String[] args) {
// 創建並賦值 HashMap
Map<Integer, String> map = new HashMap();
map.put(1, "Java");
map.put(2, "JDK");
map.put(3, "Spring Framework");
map.put(4, "MyBatis framework");
map.put(5, "Java中文社羣");
// 遍歷
map.forEach((key, value) -> {
System.out.print(key);
System.out.print(value);
});
}
}
以上程序的執行結果爲：
1 Java 2 JDK 3 Spring Framework 4 MyBatis framework 5 Java中文社羣
6.Streams API 單線程
public class HashMapTest {
public static void main(String[] args) {
// 創建並賦值 HashMap
Map<Integer, String> map = new HashMap();
map.put(1, "Java");
map.put(2, "JDK");
map.put(3, "Spring Framework");
map.put(4, "MyBatis framework");
map.put(5, "Java中文社羣");
// 遍歷
map.entrySet().stream().forEach((entry) -> {
System.out.print(entry.getKey());
System.out.print(entry.getValue());
});
}
}
以上程序的執行結果爲：
1 Java 2 JDK 3 Spring Framework 4 MyBatis framework 5 Java中文社羣
7.Streams API 多線程
public class HashMapTest {
public static void main(String[] args) {
// 創建並賦值 HashMap
Map<Integer, String> map = new HashMap();
map.put(1, "Java");
map.put(2, "JDK");
map.put(3, "Spring Framework");
map.put(4, "MyBatis framework");
map.put(5, "Java中文社羣");
// 遍歷
map.entrySet().parallelStream().forEach((entry) -> {
System.out.print(entry.getKey());
System.out.print(entry.getValue());
});
}
}
以上程序的執行結果爲：
4 MyBatis framework 5 Java中文社羣 1 Java 2 JDK 3 Spring Framework
性能測試
接下來我們使用 Oracle 官方提供的性能測試工具 JMH（Java Microbenchmark Harness，JAVA 微基準測試套件）來測試一下這 7 種循環的性能。
首先，我們先要引入 JMH 框架，在 pom.xml 文件中添加如下配置：
<!-- https://mvnrepository.com/artifact/org.openjdk.jmh/jmh-core -->
<dependency>
<groupId>org.openjdk.jmh</groupId>
<artifactId>jmh-core</artifactId>
<version>1.23</version>
</dependency>
然後編寫測試代碼，如下所示：
import org.openjdk.jmh.annotations.*;
import org.openjdk.jmh.runner.Runner;
import org.openjdk.jmh.runner.RunnerException;
import org.openjdk.jmh.runner.options.Options;
import org.openjdk.jmh.runner.options.OptionsBuilder;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.concurrent.TimeUnit;
@BenchmarkMode(Mode.Throughput) // 測試類型：吞吐量
@OutputTimeUnit(TimeUnit.MILLISECONDS)
@Warmup(iterations = 2, time = 1, timeUnit = TimeUnit.SECONDS) // 預熱 2 輪，每次 1s
@Measurement(iterations = 5, time = 3, timeUnit = TimeUnit.SECONDS) // 測試 5 輪，每次 3s
@Fork(1) // fork 1 個線程
@State(Scope.Thread) // 每個測試線程一個實例
public class HashMapCycle {
static Map<Integer, String> map = new HashMap() {{
// 添加數據
for (int i = 0; i < 10; i++) {
put(i, "val:" + i);
}
}};
public static void main(String[] args) throws RunnerException {
// 啓動基準測試
Options opt = new OptionsBuilder()
.include(HashMapCycle.class.getSimpleName()) // 要導入的測試類
.output("/Users/admin/Desktop/jmh-map.log") // 輸出測試結果的文件
.build();
new Runner(opt).run(); // 執行測試
}
@Benchmark
public void entrySet() {
// 遍歷
Iterator<Map.Entry<Integer, String>> iterator = map.entrySet().iterator();
while (iterator.hasNext()) {
Map.Entry<Integer, String> entry = iterator.next();
System.out.println(entry.getKey());
System.out.println(entry.getValue());
}
}
@Benchmark
public void keySet() {
// 遍歷
Iterator<Integer> iterator = map.keySet().iterator();
while (iterator.hasNext()) {
Integer key = iterator.next();
System.out.println(key);
System.out.println(map.get(key));
}
}
@Benchmark
public void forEachEntrySet() {
// 遍歷
for (Map.Entry<Integer, String> entry : map.entrySet()) {
System.out.println(entry.getKey());
System.out.println(entry.getValue());
}
}
@Benchmark
public void forEachKeySet() {
// 遍歷
for (Integer key : map.keySet()) {
System.out.println(key);
System.out.println(map.get(key));
}
}
@Benchmark
public void lambda() {
// 遍歷
map.forEach((key, value) -> {
System.out.println(key);
System.out.println(value);
});
}
@Benchmark
public void streamApi() {
// 單線程遍歷
map.entrySet().stream().forEach((entry) -> {
System.out.println(entry.getKey());
System.out.println(entry.getValue());
});
}
@Benchmark
public void parallelStreamApi() {
// 多線程遍歷
map.entrySet().parallelStream().forEach((entry) -> {
System.out.println(entry.getKey());
System.out.println(entry.getValue());
});
}
}
所有被添加了 @Benchmark 註解的方法都會被測試，測試結果如下：
其中 Score 列表示平均執行時間， ± 符號表示誤差。從以上結果可以看出，如果加上後面的誤差值的話，可以得出的結論是，除了並行循環的 parallelStream 性能比極高之外（多線程方式性能肯定比較高），其他方式的遍歷方法在性能方面幾乎沒有任何差別。
注：以上結果基於測試環境：JDK 1.8 / Mac mini (2018) / Idea 2020.1
性能原理分析
要理解性能測試的結果，我們需要把所有遍歷代碼通過 javac，編譯成字節碼來看具體的原因，編譯之後我們使用 Idea 打開字節碼信息，內容如下：
//
// Source code recreated from a .class file by IntelliJ IDEA
// (powered by Fernflower decompiler)
//
package com.example;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
public class HashMapTest {
static Map<Integer, String> map = new HashMap() {
{
for(int var1 = 0; var1 < 2; ++var1) {
this.put(var1, "val:" + var1);
}
}
};
public HashMapTest() {
}
public static void main(String[] var0) {
entrySet();
keySet();
forEachEntrySet();
forEachKeySet();
lambda();
streamApi();
parallelStreamApi();
}
public static void entrySet() {
Iterator var0 = map.entrySet().iterator();
while(var0.hasNext()) {
Entry var1 = (Entry)var0.next();
System.out.println(var1.getKey());
System.out.println((String)var1.getValue());
}
}
public static void keySet() {
Iterator var0 = map.keySet().iterator();
while(var0.hasNext()) {
Integer var1 = (Integer)var0.next();
System.out.println(var1);
System.out.println((String)map.get(var1));
}
}
public static void forEachEntrySet() {
Iterator var0 = map.entrySet().iterator();
while(var0.hasNext()) {
Entry var1 = (Entry)var0.next();
System.out.println(var1.getKey());
System.out.println((String)var1.getValue());
}
}
public static void forEachKeySet() {
Iterator var0 = map.keySet().iterator();
while(var0.hasNext()) {
Integer var1 = (Integer)var0.next();
System.out.println(var1);
System.out.println((String)map.get(var1));
}
}
public static void lambda() {
map.forEach((var0, var1) -> {
System.out.println(var0);
System.out.println(var1);
});
}
public static void streamApi() {
map.entrySet().stream().forEach((var0) -> {
System.out.println(var0.getKey());
System.out.println((String)var0.getValue());
});
}
public static void parallelStreamApi() {
map.entrySet().parallelStream().forEach((var0) -> {
System.out.println(var0.getKey());
System.out.println((String)var0.getValue());
});
}
}
從結果可以看出，除了 Lambda 和 Streams API 之外，通過迭代器循環和 for 循環的遍歷的 EntrySet 最終生成的代碼是一樣的，他們都是在循環中創建了一個遍歷對象 Entry ，如下所示：
public static void entrySet() {
Iterator var0 = map.entrySet().iterator();
while(var0.hasNext()) {
Entry var1 = (Entry)var0.next();
System.out.println(var1.getKey());
System.out.println((String)var1.getValue());
}
}
public static void forEachEntrySet() {
Iterator var0 = map.entrySet().iterator();
while(var0.hasNext()) {
Entry var1 = (Entry)var0.next();
System.out.println(var1.getKey());
System.out.println((String)var1.getValue());
}
}
而通過迭代器和 for 循環遍歷的 KeySet 代碼也是一樣的，如下所示：
public static void keySet() {
Iterator var0 = map.keySet().iterator();
while(var0.hasNext()) {
Integer var1 = (Integer)var0.next();
System.out.println(var1);
System.out.println((String)map.get(var1));
}
}
public static void forEachKeySet() {
Iterator var0 = map.keySet().iterator();
while(var0.hasNext()) {
Integer var1 = (Integer)var0.next();
System.out.println(var1);
System.out.println((String)map.get(var1));
}
}
可以看出 KeySet 在循環中創建了一個 Integer 的局部變量，並且值是從 map 對象中直接獲取的。
所以通過字節碼來看，使用 EntrySet 和 KeySet 代碼差別不是很大，並不像網上說的那樣 KeySet 的性能遠不如 EntrySet，因此從性能的角度來說 EntrySet 和 KeySet 幾乎是相近的，但從代碼的優雅型和可讀性來說，還是推薦使用 EntrySet。
安全性測試
從上面的性能測試結果和原理分析，我想大家應該選用那種遍歷方式，已經心中有數的，而接下來我們就從「安全」的角度入手，來分析那種遍歷方式更安全。
我們把以上遍歷劃分爲四類進行測試：迭代器方式、For 循環方式、Lambda 方式和 Stream 方式，測試代碼如下。
1.迭代器方式
Iterator<Map.Entry<Integer, String>> iterator = map.entrySet().iterator();
while (iterator.hasNext()) {
Map.Entry<Integer, String> entry = iterator.next();
if (entry.getKey() == 1) {
// 刪除
System.out.println("del:" + entry.getKey());
iterator.remove();
} else {
System.out.println("show:" + entry.getKey());
}
}
以上程序的執行結果：
show:0
del:1
show:2
測試結果：迭代器中循環刪除數據安全。
2.For 循環方式
for (Map.Entry<Integer, String> entry : map.entrySet()) {
if (entry.getKey() == 1) {
// 刪除
System.out.println("del:" + entry.getKey());
map.remove(entry.getKey());
} else {
System.out.println("show:" + entry.getKey());
}
}
以上程序的執行結果：
測試結果：For 循環中刪除數據非安全。
3.Lambda 方式
map.forEach((key, value) -> {
if (key == 1) {
System.out.println("del:" + key);
map.remove(key);
} else {
System.out.println("show:" + key);
}
});
以上程序的執行結果：
Lambda 刪除的正確方式：
// 根據 map 中的 key 去判斷刪除
map.keySet().removeIf(key -> key == 1);
map.forEach((key, value) -> {
System.out.println("show:" + key);
});
以上程序的執行結果：
show:0
show:2
從上面的代碼可以看出，可以先使用 Lambda 的 removeIf 刪除多餘的數據，再進行循環是一種正確操作集合的方式。
4.Stream 方式
map.entrySet().stream().forEach((entry) -> {
if (entry.getKey() == 1) {
System.out.println("del:" + entry.getKey());
map.remove(entry.getKey());
} else {
System.out.println("show:" + entry.getKey());
}
});
以上程序的執行結果：
測試結果：Stream 循環中刪除數據非安全。
Stream 循環的正確方式：
map.entrySet().stream().filter(m -> 1 != m.getKey()).forEach((entry) -> {
if (entry.getKey() == 1) {
System.out.println("del:" + entry.getKey());
} else {
System.out.println("show:" + entry.getKey());
}
});
以上程序的執行結果：
show:0
show:2
從上面的代碼可以看出，可以使用 Stream 中的 filter 過濾掉無用的數據，再進行遍歷也是一種安全的操作集合的方式。
小結
我們不能在遍歷中使用集合 map.remove() 來刪除數據，這是非安全的操作方式，但我們可以使用迭代器的 iterator.remove() 的方法來刪除數據，這是安全的刪除集合的方式。同樣的我們也可以使用 Lambda 中的 removeIf 來提前刪除數據，或者是使用 Stream 中的 filter 過濾掉要刪除的數據進行循環，這樣都是安全的，當然我們也可以在 for 循環前刪除數據在遍歷也是線程安全的。
總結
本文我們講了 HashMap 4 大類（迭代器、for、lambda、stream）遍歷方式，以及具體的 7 種遍歷方法，除了 Stream 的並行循環，其他幾種遍歷方法的性能差別不大，但從簡潔性和優雅性上來看，Lambda 和 Stream 無疑是最適合的遍歷方式。除此之外我們還從「安全性」方面測試了 4 大類遍歷結果，從安全性來講，我們應該使用迭代器提供的 iterator.remove() 方法來進行刪除，這種方式是安全的在遍歷中刪除集合的方式，或者使用 Stream 中的 filter 過濾掉要刪除的數據再進行循環，也是安全的操作方式。
總體來說，本文提供了 7 種方式肯定也不是最全的，我是想給讀者在使用 HashMap 時多一種選擇，然而選擇那一種形式的寫法，要綜合：性能、安全性、使用環境的 JDK 版本以及優雅性和可讀性等方面來綜合考慮。最後，歡迎各位在評論區補充並留言，寫出你們的想法。
最後的話
原創不易，如果覺得本文對你有用，請隨手點擊一個「在看」，這是對作者最大的支持與鼓勵，謝謝你。
參考 & 鳴謝
https://www.javaguides.net/2020/03/5-best-ways-to-iterate-over-hashmap-in-java.html
關注公衆號發送”進羣“，老王拉你進讀者羣。