HashMap 的 7 種遍歷方式與效能分析

DOONDO發表於2022-02-11

HashMap

前言

隨著 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.println(entry.getKey());
            System.out.println(entry.getValue());
        }
    }
}

以上程式的執行結果為：

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.println(key);
            System.out.println(map.get(key));
        }
    }
}

以上程式的執行結果為：

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.println(entry.getKey());
            System.out.println(entry.getValue());
        }
    }
}

以上程式的執行結果為：

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.println(key);
            System.out.println(map.get(key));
        }
    }
}

以上程式的執行結果為：

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.println(key);
            System.out.println(value);
        });
    }
}

以上程式的執行結果為：

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.println(entry.getKey());
            System.out.println(entry.getValue());
        });
    }
}

以上程式的執行結果為：

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.println(entry.getKey());
            System.out.println(entry.getValue());
        });
    }
}

以上程式的執行結果為：

效能測試

接下來我們使用 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>
<!-- https://mvnrepository.com/artifact/org.openjdk.jmh/jmh-generator-annprocess -->
<dependency>
    <groupId>org.openjdk.jmh</groupId>
    <artifactId>jmh-generator-annprocess</artifactId>
    <version>1.23</version>
    <scope>provided</scope>
</dependency>

然後編寫測試程式碼，如下所示：

@BenchmarkMode(Mode.AverageTime) // 測試完成時間
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@Warmup(iterations = 2, time = 1, timeUnit = TimeUnit.SECONDS) // 預熱 2 輪，每次 1s
@Measurement(iterations = 5, time = 1, timeUnit = TimeUnit.SECONDS) // 測試 5 輪，每次 1s
@Fork(1) // fork 1 個執行緒
@State(Scope.Thread) // 每個測試執行緒一個例項
public class HashMapCycleTest {
    static Map<Integer, String> map = new HashMap() {{
        // 新增資料
        for (int i = 0; i < 100; 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();
            Integer k = entry.getKey();
            String v = entry.getValue();
        }
    }

    @Benchmark
    public void forEachEntrySet() {
        // 遍歷
        for (Map.Entry<Integer, String> entry : map.entrySet()) {
            Integer k = entry.getKey();
            String v = entry.getValue();
        }
    }

    @Benchmark
    public void keySet() {
        // 遍歷
        Iterator<Integer> iterator = map.keySet().iterator();
        while (iterator.hasNext()) {
            Integer k = iterator.next();
            String v = map.get(k);
        }
    }

    @Benchmark
    public void forEachKeySet() {
        // 遍歷
        for (Integer key : map.keySet()) {
            Integer k = key;
            String v = map.get(k);
        }
    }

    @Benchmark
    public void lambda() {
        // 遍歷
        map.forEach((key, value) -> {
            Integer k = key;
            String v = value;
        });
    }

    @Benchmark
    public void streamApi() {
        // 單執行緒遍歷
        map.entrySet().stream().forEach((entry) -> {
            Integer k = entry.getKey();
            String v = entry.getValue();
        });
    }

    public void parallelStreamApi() {
        // 多執行緒遍歷
        map.entrySet().parallelStream().forEach((entry) -> {
            Integer k = entry.getKey();
            String v = entry.getValue();
        });
    }
}

所有被新增了 @Benchmark 註解的方法都會被測試，因為 parallelStream 為多執行緒版本效能一定是最好的，所以就不參與測試了，其他 6 個方法的測試結果如下：

其中 Units 為 ns/op 意思是執行完成時間（單位為納秒），而 Score 列為平均執行時間， ± 符號表示誤差。從以上結果可以看出，兩個 entrySet 的效能相近，並且執行速度最快，接下來是 stream ，然後是兩個 keySet，效能最差的是 KeySet 。

結論

從以上結果可以看出 entrySet 的效能比 keySet 的效能高出了一倍之多，因此我們應該儘量使用 entrySet 來實現 Map 集合的遍歷。

位元組碼分析

要理解以上的測試結果，我們需要把所有遍歷程式碼通過 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());
    }
}

而 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));
    }
}

所以我們在使用迭代器或是 for 迴圈 EntrySet 時，他們的效能都是相同的，因為他們最終生成的位元組碼基本都是一樣的；同理 KeySet 的兩種遍歷方式也是類似的。

效能分析

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 方式，測試程式碼如下。

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());
    }
}

以上程式的執行結果：

測試結果：迭代器中迴圈刪除資料安全。

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 迴圈中刪除資料非安全。

Lambda 刪除的正確方式：

// 根據 map 中的 key 去判斷刪除
map.keySet().removeIf(key -> key == 1);
map.forEach((key, value) -> {
    System.out.println("show:" + key);
});

以上程式的執行結果：

從上面的程式碼可以看出，可以先使用 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());
    }
});

以上程式的執行結果：

從上面的程式碼可以看出，可以使用 Stream 中的 filter 過濾掉無用的資料，再進行遍歷也是一種安全的操作集合的方式。

小結

我們不能在遍歷中使用集合 map.remove() 來刪除資料，這是非安全的操作方式，但我們可以使用迭代器的 iterator.remove() 的方法來刪除資料，這是安全的刪除集合的方式。同樣的我們也可以使用 Lambda 中的 removeIf 來提前刪除資料，或者是使用 Stream 中的 filter 過濾掉要刪除的資料進行迴圈，這樣都是安全的，當然我們也可以在 for 迴圈前刪除資料在遍歷也是執行緒安全的。

總結

本文我們講了 HashMap 4 種遍歷方式：迭代器、for、lambda、stream，以及具體的 7 種遍歷方法，綜合效能和安全性來看，我們應該儘量使用迭代器（Iterator）來遍歷 EntrySet 的遍歷方式來操作 Map 集合，這樣就會既安全又高效了。

JS遍歷物件屬性的7種方式
2022-06-19
JS物件
ArrayList和LinkedList的幾種迴圈遍歷方式及效能對比分析
2014-06-30
HashMap原始碼：聊聊Map的遍歷效能問題（一）
2021-06-08
HashMap原始碼
Java遍歷Map物件的四種方式
2018-12-29
Java物件
遍歷資料夾的幾種方式
2018-07-26
遍歷PHP陣列的6種方式
2018-06-16
PHP陣列
C++ Vector遍歷的幾種方式（）
2017-12-18
C++
Java Map遍歷方式方式及效能測試
2015-01-12
Java
JavaScript 各種遍歷方式詳解
2015-11-09
JavaScript
集合框架-集合的巢狀遍歷（HashMap巢狀HashMap）
2017-05-01
框架巢狀HashMap
php陣列中常用的多種遍歷方式
2020-04-04
PHP陣列
如何從效能角度選擇陣列的遍歷方式
2021-11-23
陣列
JS遍歷物件的方式
2018-12-05
JS物件
php手冊 php陣列的遍歷有哪幾種方式？php陣列如何遍歷？
2021-04-16
PHP陣列
python中字典的迴圈遍歷的兩種方式
2016-12-01
Python
JavaHashMap遍歷實踐，看看不同方式的效能如何
2016-03-04
JavaHashMap
java集合遍歷的幾種方式總結及比較
2016-11-04
Java
iOS開發中陣列常用的五種遍歷方式
2017-01-03
iOS陣列
Java之HashMap集合簡介及遍歷
2018-07-30
JavaHashMap
java List＜HashMap＜String,Object＞＞遍歷修改
2024-03-09
JavaHashMapObject
一文弄懂二叉樹的三種遍歷方式
2021-11-09
二叉樹
python字串遍歷方式
2020-12-08
Python字串
js 遍歷陣列方式
2020-09-27
JS陣列
集合框架-集合的巢狀遍歷（HashMap巢狀ArrayList）
2017-05-01
框架巢狀HashMap
集合框架-集合的巢狀遍歷（ArrayList巢狀HashMap）
2017-05-01
框架巢狀HashMap
影片直播系統原始碼，java中Map遍歷的三種方式
2023-02-07
原始碼Java
Java 中九種 Map 的遍歷方式，你一般用的是哪種呢？
2022-11-23
Java
JS遍歷物件的幾種方法
2020-06-16
JS物件
JavaScript中遍歷的幾種方法
2020-12-14
JavaScript
遍歷陣列的幾種方法
2020-10-01
陣列
JS中遍歷陣列、物件的方式
2018-11-05
JS陣列物件
Python字典的遍歷,包括key遍歷/value遍歷/item遍歷/
2020-12-07
Python
JavaScript 各種遍歷方式詳解，有你不知道的黑科技
2015-11-10
JavaScript
ios 遍歷陣列的八種方法
2016-11-03
iOS陣列
jquery中each的三種遍歷方法
2016-07-24
jQuery
java中遍歷Map的4種方法
2015-07-15
Java
二叉樹的四種遍歷（遞迴與非遞迴）
2021-10-06
二叉樹遞迴
js的map遍歷和array遍歷
2018-11-15
JS

HashMap 的 7 種遍歷方式與效能分析

前言

HashMap 遍歷

1.迭代器 EntrySet

2.迭代器 KeySet

3.ForEach EntrySet

4.ForEach KeySet

5.Lambda

6.Streams API 單執行緒

7.Streams API 多執行緒

效能測試

結論

位元組碼分析

效能分析

安全性測試

1.迭代器方式

2.For 迴圈方式

3.Lambda 方式

4.Stream 方式

小結

總結

相關文章