HashMap 最見功底！

時間  2020-11-30
標籤 html java web 編程 安全 微信 多線程 框架 編輯器 ide 欄目 HTML 简体版
原文   原文鏈接

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

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


HashMap 遍歷

HashMap 遍歷從大的方向來講，可分爲如下 4 類：web

  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

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

以上程序的執行結果爲：微信

1多線程

Java框架

2編輯器

JDKide

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.println(key);
            System.out.println(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.println(entry.getKey());
            System.out.println(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.println(key);
            System.out.println(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.println(key);
            System.out.println(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.println(entry.getKey());
            System.out.println(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.println(entry.getKey());
            System.out.println(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>
<!-- 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 。

注：以上結果基於測試環境：JDK 1.8 / Mac mini (2018) / Idea 2020.1

結論

從以上結果能夠看出 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());
    }
}

以上程序的執行結果：

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

以上程序的執行結果：

image.png

測試結果：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());
    }
});

以上程序的執行結果：

image.png

測試結果：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 集合，這樣就會既安全又高效了。

參考 & 鳴謝

https://www.javaguides.net/2020/03/5-best-ways-to-iterate-over-hashmap-in-java.html

END




推薦閱讀：


喜歡我能夠給我設爲星標哦

好文章，我 「在看」

本文分享自微信公衆號 - 漫話編程（mhcoding）。
若有侵權，請聯繫 support@oschina.cn 刪除。
本文參與「OSC源創計劃」，歡迎正在閱讀的你也加入，一塊兒分享。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程