隨著 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
以上程式的執行結果為：
1 Java 2 JDK 3 Spring Framework 4 MyBatis framework
2.迭代器 KeySet
以上程式的執行結果為：
1 Java 2 JDK 3 Spring Framework 4 MyBatis framework
3.ForEach EntrySet
以上程式的執行結果為：
1 Java 2 JDK 3 Spring Framework 4 MyBatis framework 5 Java中文社群
4.ForEach KeySet
以上程式的執行結果為：
1 Java 2 JDK 3 Spring Framework 4 MyBatis framework 5 Java中文社群
5.Lambda
以上程式的執行結果為：
1 Java 2 JDK 3 Spring Framework 4 MyBatis framework 5 Java中文社群
6.Streams API 單執行緒
以上程式的執行結果為：
1 Java 2 JDK 3 Spring Framework 4 MyBatis framework 5 Java中文社群
7.Streams API 多執行緒
以上程式的執行結果為：
4 MyBatis framework 5 Java中文社群 1 Java 2 JDK 3 Spring Framework
性能測驗
接下來我們使用 Oracle 官方提供的性能測驗工具 JMH（Java Microbenchmark Harness，JAVA 微基準測驗套件）來測驗一下這 7 種回圈的性能，
首先，我們先要引入 JMH 框架，在 pom.xml 檔案中添加如下配置：
然后撰寫測驗代碼，如下所示：
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 ，如下所示：
而通過迭代器和 for 回圈遍歷的 KeySet 代碼也是一樣的，如下所示：
可以看出 KeySet 在回圈中創建了一個 Integer 的區域變數，并且只是從map 物件中直接獲取的，
所以通過位元組碼來看，使用 EntrySet 和 KeySet 代碼差別不是很大，并不像網上說的那樣 KeySet 的性能遠不如 EntrySet，因此從性能的角度來說 EntrySet 和 KeySet 幾乎是相近的，但從代碼的優雅性和可讀性來說，還是推薦使用 EntrySet，
安全性測驗
從上面的性能測驗結果和原理分析，我想大家應該選用那種遍歷方式，已經心中有數的，而接下來我們就從「安全」的角度入手，來分析那種遍歷方式更安全，
我們把以上遍歷劃分為四類進行測驗：迭代器方式、For 回圈方式、Lambda 方式和 Stream 方式，測驗代碼如下，
1.迭代器方式
以上程式的執行結果：
show:0
del:1
show:2
測驗結果：迭代器中回圈洗掉資料安全，
2.For 回圈方式
以上程式的執行結果：
測驗結果：For 回圈中洗掉資料非安全，
3.Lambda 方式
以上程式的執行結果：
測驗結果：Lambda 回圈中洗掉資料非安全，
Lambda 洗掉的正確方式：
以上程式的執行結果：
show:0
show:2
從上面的代碼可以看出，可以先使用 Lambda 的 removeIf 洗掉多余的資料，再進行回圈是一種正確操作集合的方式，
4.Stream 方式
以上程式的執行結果：
測驗結果：Stream 回圈中洗掉資料非安全，
Stream 回圈的正確方式：
以上程式的執行結果：
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.uj5u.com/houduan/184528.html
標籤：Java