2. 程式人生 > 其它 >HashMap 中7種遍歷方式的效能分析

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

阿新 • • 發佈：2021-06-25

隨著 JDK 1.8 Streams API 的釋出，使得 HashMap 擁有了更多的遍歷的方式，但應該選擇那種遍歷方式？反而成了一個問題。

本文先從 HashMap 的遍歷方法講起，然後再從效能、原理以及安全性等方面，來分析 HashMap 各種遍歷方式的優勢與不足，本文主要內容如下圖所示：

HashMap遍歷

HashMap遍歷從大的方向來說，可分為以下 4 類：

  1. 迭代器（Iterator）方式遍歷；
  2. For Each 方式遍歷；
  3. Lambda 表示式遍歷（JDK 1.8+）;
  4. Streams API 遍歷（JDK 1.8+）。

但每種型別下又有不同的實現方式，因此具體的遍歷方式又可以分為以下 7 種：

  1. 使用迭代器（Iterator）EntrySet 的方式進行遍歷；
  2. 使用迭代器（Iterator）KeySet 的方式進行遍歷；
  3. 使用 For Each EntrySet 的方式進行遍歷；
  4. 使用 For Each KeySet 的方式進行遍歷；
  5. 使用 Lambda 表示式的方式進行遍歷；
  6. 使用 Streams API 單執行緒的方式進行遍歷；
  7. 使用 Streams API 多執行緒的方式進行遍歷。

接下來我們來看每種遍歷方式的具體實現程式碼。

1.迭代器EntrySet

    @Test
    public void testIterator() {
        // 建立並賦值 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, "Oracle Database");
        // 遍歷
        Iterator<Map.Entry<Integer, String>> iterator = map.entrySet().iterator();
        
 
while (iterator.hasNext()) {
            Map.Entry<Integer, String> entry = iterator.next();
            System.out.println(entry.getKey() + ":" + entry.getValue());
        }
    }

執行結果：

2.迭代器 KeySet

    @Test
    public void testKeySet() {
        // 建立並賦值 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, "Test KeySet");
        // 遍歷
        Iterator<Integer> iterator = map.keySet().iterator();
        while (iterator.hasNext()) {
            Integer key = iterator.next();
            System.out.println(key + ":" + map.get(key));
        }
    }

執行結果：

3.ForEachEntrySet

    @Test
    public void testForEachEntrySet() {
        // 建立並賦值 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, "Test ForEach EntrySet");
        // 遍歷
        for (Map.Entry<Integer, String> entry : map.entrySet()) {
            System.out.println(entry.getKey() + ":" + entry.getValue());
        }
    }

執行結果：

4.ForEach KeySet

    @Test
    public void testForEachKeySet() {
        // 建立並賦值 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, "Test ForEach KeySet");
        // 遍歷
        for (Integer key : map.keySet()) {
            System.out.println(key + ":" + map.get(key));
        }
    }

執行結果：

5.Lambda

    @Test
    public void testLambda() {
        // 建立並賦值 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, "Test Lambda");
        // 遍歷
        map.forEach((key, value) -> {
            System.out.println(key + ":" + value);
        });
    }

執行結果：

6.Streams API 單執行緒

    @Test
    public void testStreamApi() {
        // 建立並賦值 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, "Test Stream API");
        // 遍歷
        map.entrySet().stream().forEach((entry) -> {
            System.out.println(entry.getKey() + ":" + entry.getValue());
        });
    }

執行結果：

7.Streams API 多執行緒

    @Test
    public void testParallelStreamApi() {
        // 建立並賦值 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, "Test Parallel Stream API");
        // 遍歷
        map.entrySet().parallelStream().forEach((entry) -> {
            System.out.println(entry.getKey() + ":" + entry.getValue());
        });
    }

執行結果：

效能分析

接下來我們使用 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，可引入如下配置：

<!-- 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>

編寫效能測試程式碼如下：

/**
 * @version V1.0
 * @description HashMap 的 7 種遍歷方式+效能分析
 * @author zhangzg
 * @date 2021/6/25 13:12
 */
//@BenchmarkMode(Mode.Throughput) // 測試型別：吞吐量
@BenchmarkMode(Mode.AverageTime) // 測試型別：平均消耗時間
//@OutputTimeUnit(TimeUnit.MILLISECONDS)
@OutputTimeUnit(TimeUnit.NANOSECONDS)
@Warmup(iterations = 4, time = 1, timeUnit = TimeUnit.SECONDS) // 預熱 4 輪，每次 1s
@Measurement(iterations = 10, time = 3, timeUnit = TimeUnit.SECONDS) // 測試 10 輪，每次 3s
@Fork(1) // fork 1 個執行緒
@State(Scope.Thread) // 每個測試執行緒一個例項
public class HashMapTest {

    static Map<Integer, String> map = new HashMap() {
        {
            for(int var1 = 0; var1 < 2; ++var1) {
                this.put(var1, "Kevin:" + var1);
            }

        }
    };

    public static void main(String[] args) throws RunnerException {
        // 啟動基準測試
        Options opt = new OptionsBuilder()
                .include(HashMapTest.class.getSimpleName()) // 要匯入的測試類
                .output("E:/IDEAWorkSpaces/Test/src/main/java/com/kevin/performance/jmh-map2.log") // 輸出測試結果的檔案
                .build();
        new Runner(opt).run(); // 執行測試
    }

    /**
     * Iterator遍歷 entrySet
     */
    @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();
        }
    }

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

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

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

    /**
     * Lambda遍歷
     */
    @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 為多執行緒版本效能一定由於其他單執行緒，故不參與本次測試），測試結果如下：

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

結論

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

位元組碼分析

要理解以上的測試結果，我們需要把所有遍歷程式碼通過javac編譯成位元組碼來看具體的原因。

編譯後，我們使用 Idea 開啟位元組碼，內容如下：

public class HashMapTest {
    static Map<Integer, String> map = new HashMap() {
        {
            for(int var1 = 0; var1 < 2; ++var1) {
                this.put(var1, "Kevin:" + 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() + ":" + (String)var1.getValue());
        }
    }

    public static void keySet() {
        Iterator var0 = map.keySet().iterator();

        while(var0.hasNext()) {
            Integer var1 = (Integer)var0.next();
            System.out.println(var1 + ":" + (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() + ":" + (String)var1.getValue());
        }
    }

    public static void forEachKeySet() {
        Iterator var0 = map.keySet().iterator();

        while(var0.hasNext()) {
            Integer var1 = (Integer)var0.next();
            System.out.println(var1 + ":" + (String)map.get(var1));            
        }
    }

    public static void lambda() {
        map.forEach((var0, var1) -> {
            System.out.println(var0 + ":" + var1);            
        });
    }

    public static void streamApi() {
        map.entrySet().stream().forEach((var0) -> {
            System.out.println(var0.getKey() + ":" + (String)var0.getValue());
        });
    }

    public static void parallelStreamApi() {
        map.entrySet().parallelStream().forEach((var0) -> {
            System.out.println(var0.getKey() + ":" + (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() + ":" + (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() + ":" + (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 + ":" + (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 + ":" + (String)map.get(var1));
    }
}

從結果可以看出，除了 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() + ":" + (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() + ":" + (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 + ":" + (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 + ":" + (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());
    }
}

執行結果：

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

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 種遍歷方法，綜合性能和安全性來看，我們應該儘量使用迭代器（Iterator）來遍歷EntrySet的遍歷方式來操作 Map 集合，這樣就會既安全又高效了。

原文參考公眾號【Java知音】

相關推薦

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

隨著 JDK 1.8 Streams API 的釋出，使得 HashMap 擁有了更多的遍歷的方式，但應該選擇那種遍歷方式？反而成了一個問題。

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

隨著 JDK 1.8 Streams API 的釋出，使得 HashMap 擁有了更多的遍歷的方式，但應該選擇那種遍歷方式？反而成了一個問題。

HashMap中兩種遍歷方法

技術標籤：hashmapjava HashMap<Integer, Integer> map = new HashMap<>(); map.put(1,101);

HashMap的四種遍歷方式

HashMap的四種遍歷方式 package com.learning.java; import java.util.HashMap; import java.util.Iterator;

HashMap兩種遍歷方式

package com.czie.iot1913.lps.Map;import java.util.HashMap;import java.util.Map;import java.util.Set;/** * @author [email protected] * @date 2022-03-20 20:24 */public class MapTest06 {public static voi

基於Java的二叉樹的三種遍歷方式的遞迴與非遞迴實現

二叉樹的遍歷方式包括前序遍歷、中序遍歷和後序遍歷，其實現方式包括遞迴實現和非遞迴實現。

[資料結構--樹] 樹的四種遍歷方式

一、引言前面介紹了樹的一些基本概念，接下來將實現樹的各種操作。樹主要應用廣的還是二叉樹，因此主要實現二叉樹的各類操作，包括建立、刪除、查詢、遍歷等等。其中樹的基本操作最重要的是遍歷，因此首先專門講解並

C++11 for區間遍歷:vector幾種遍歷方式

近來，基本上所有現代程式語言都有一種對一個區間寫for迴圈的便捷方式。最終，C++也有了相同的概念；你可以給迴圈提供一個容器，它幫你迭代。

Map的四種遍歷方式- 詳解以及用法

Entry 由於Map中存放的元素均為鍵值對，故每一個鍵值對必然存在一個對映關係。Map中採用Entry內部類來表示一個對映項，對映項包含Key和Value (我們總說鍵值對鍵值對, 每一個鍵值對也就是一個Entry)Map.Entry裡面包含

資料結構 | 二叉樹的建立和三種遍歷方式

二叉樹的建立和三種遍歷方式 幫同學寫作業順帶複習了一下 直接丟程式碼了：

Python字典（dict ）的幾種遍歷方式

1.使用 for key in dict 遍歷字典 可以使用for key in dict遍歷字典中所有的鍵 x = {\'a\': \'A\', \'b\': \'B\'}

[HashMap]HashMap有幾種遍歷方法

HashMap有幾種遍歷方法 HashMap 的遍歷方法有很多種，不同的 JDK 版本有不同的寫法，其中 JDK 8 就提供了 3 種 HashMap 的遍歷方法，並且一舉打破了之前遍歷方法“很臃腫”的尷尬。

Map的5種遍歷方式

Map的5種遍歷方式 Map<String, String> map = new HashMap<String, String>(); map.put(\"bors\", \"博士\");

Java中四種遍歷集合的方法

Java中四種遍歷集合的方法迭代是集合中進行的基本操作之一。基本上，迭代是從一個到另一個集合

Java HashMap三種迴圈遍歷方式及其效能對比例項分析

本文例項講述了Java HashMap三種迴圈遍歷方式及其效能對比。分享給大家供大家參考，具體如下：

Java中列表幾種迴圈遍歷方式的耗時對比(for/foreach/stream/parallelStream)

技術標籤：Java基礎篇Javajavalambdastream 栗子：定義一個數組,賦值十萬條資料。然後分別使用四種方式遍歷該陣列、取出name不包含4的所有列表

Java5種遍歷HashMap資料的寫法

本文介紹了最好的Java5種遍歷HashMap資料的寫法，分享給大家，也給自己留一個筆記，具體如下：

JS 5種遍歷物件的方式

幾天前一個小夥伴問我 Object.getOwnPropertyNames() 是幹什麼用的 平時還真沒有使用到這個方法，一時不知如何回答

C#中Collection和Dictionary的foreach遍歷方式

原文：http://blog.sojingle.net/programming/csharp/csharp-collections-dictionaries-using-foreach 對於.net Framework中內建的幾種集合類，foreach是一種很方便的遍歷方式：

JS——幾種陣列遍歷方式總結

序言 　　本文是轉載內容，但是原版已不可尋，此處貼出本文轉載來源，點選進入原文：CSDN