淺談HashMap中7種遍歷方式的性能分析

Posted on 2021-06-30 by WalkonNet

一、前言

隨著 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

@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.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));
        }
    }

運行結果：

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

運行結果：

2.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));
        }
    }

運行結果：

2.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);
        });
    }

運行結果：

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

運行結果：

2.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>

編寫性能測試代碼如下：

//@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性能分析

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、迭代器方式

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

測試結果：迭代器中循環刪除數據安全。

6.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 循環中刪除數據非安全。

6.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刪除多餘的數據，再進行循環是一種正確操作集合的方式。

6.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過濾掉無用的數據，再進行遍歷也是一種安全的操作集合的方式。

6.5、小結

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

七、總結

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

以上就是淺談HashMap中7種遍歷方式的性能分析的詳細內容，更多關於HashMap 遍歷性能分析的資料請關註WalkonNet其它相關文章！

淺談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、小結

七、總結

推薦閱讀：

發佈留言取消回覆

近期文章

目錄

一、前言

二、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、小結

七、總結

推薦閱讀：

發佈留言 取消回覆

近期文章

標籤

發佈留言取消回覆