淺談HashMap中7種遍歷方式的性能分析
更新時間：2021年06月30日 11:19:06 作者：Kevin.ZhangCG
本文先從HashMap的遍歷方法講起，然后再從性能、原理以及安全性等方面，來分析HashMap各種遍歷方式的優(yōu)勢與不足
一、前言
隨著 JDK 1.8 Streams API 的發(fā)布，使得 HashMap 擁有了更多的遍歷的方式，但應該選擇那種遍歷方式？反而成了一個問題。
本文主要內容如下圖所示：
二、HashMap遍歷
HashMap遍歷從大的方向來說，可分為以下 4 類：
- 迭代器（Iterator）方式遍歷；
- For Each 方式遍歷；
- Lambda 表達式遍歷（JDK 1.8+）;
- Streams API 遍歷（JDK 1.8+）。
但每種類型下又有不同的實現(xiàn)方式，因此具體的遍歷方式又可以分為以下 7 種：
- 使用迭代器（Iterator）EntrySet 的方式進行遍歷；
- 使用迭代器（Iterator）KeySet 的方式進行遍歷；
- 使用 For Each EntrySet 的方式進行遍歷；
- 使用 For Each KeySet 的方式進行遍歷；
- 使用 Lambda 表達式的方式進行遍歷；
- 使用 Streams API 單線程的方式進行遍歷；
- 使用 Streams API 多線程的方式進行遍歷。
接下來我們來看每種遍歷方式的具體實現(xiàn)代碼。
2.1、迭代器EntrySet
@Test
public void testIterator() {
// 創(chuàng)建并賦值 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() {
// 創(chuàng)建并賦值 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() {
// 創(chuàng)建并賦值 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() {
// 創(chuàng)建并賦值 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() {
// 創(chuàng)建并賦值 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() {
// 創(chuàng)建并賦值 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() {
// 創(chuàng)建并賦值 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 種循環(huán)的性能。
首先我們需要引入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(); // 執(zhí)行測試
}
/**
* 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 意思是執(zhí)行完成時間（單位為納秒），而 Score 列為平均執(zhí)行時間，±符號表示誤差。從以上結果可以看出，兩個entrySet的性能相近，并且執(zhí)行速度最快，接下來是stream，然后是兩個keySet，性能最差的是KeySet。
結論：
從以上結果可以看出entrySet的性能比keySet的性能高出了一倍之多，因此我們應該盡量使用entrySet來實現(xiàn) Map集合的遍歷。
四、字節(jié)碼分析
要理解以上的測試結果，我們需要把所有遍歷代碼通過javac編譯成字節(jié)碼來看具體的原因。
編譯后，我們使用 Idea 打開字節(jié)碼，內容如下：
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 之外，通過迭代器循環(huán)和 for 循環(huán)的遍歷的 EntrySet 最終生成的代碼是一樣的，他們都是在循環(huán)中創(chuàng)建了一個遍歷對象 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 之外，通過迭代器循環(huán)和for循環(huán)的遍歷的EntrySet最終生成的代碼是一樣的，他們都是在循環(huán)中創(chuàng)建了一個遍歷對象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循環(huán)EntrySet時，他們的性能都是相同的，因為他們最終生成的字節(jié)碼基本都是一樣的；同理KeySet的兩種遍歷方式也是類似的。
五、EntrySet性能分析
EntrySet之所以比KeySet的性能高是因為，KeySet在循環(huán)時使用了map.get(key)，而map.get(key)相當于又遍歷了一遍 Map 集合去查詢key所對應的值。為什么要用“又”這個詞？那是因為在使用迭代器或者 for 循環(huán)時，其實已經遍歷了一遍 Map 集合了，因此再使用map.get(key)查詢時，相當于遍歷了兩遍。
而EntrySet只遍歷了一遍 Map 集合，之后通過代碼“Entry<Integer, String> entry = iterator.next()”把對象的key和value值都放入到了Entry對象中，因此再獲取key和value值時就無需再遍歷 Map 集合，只需要從Entry對象中取值就可以了。
所以，EntrySet的性能比KeySet的性能高出了一倍，因為KeySet相當于循環(huán)了兩遍 Map 集合，而EntrySet只循環(huán)了一遍。
六、安全性測試
從上面的性能測試結果和原理分析，我想大家應該選用那種遍歷方式，已經心中有數(shù)的，而接下來我們就從「安全」的角度入手，來分析那種遍歷方式更安全。
我們把以上遍歷劃分為四類進行測試：迭代器方式、For 循環(huán)方式、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
測試結果：迭代器中循環(huán)刪除數(shù)據安全。
6.2、For 循環(huán)方式
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 循環(huán)中刪除數(shù)據非安全。
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 循環(huán)中刪除數(shù)據非安全。
Lambda 刪除的正確方式：
// 根據 map 中的 key 去判斷刪除
map.keySet().removeIf(key -> key == 1);
map.forEach((key, value) -> {
System.out.println("show:" + key);
});
運行結果：
show:0
show:2
從上面的代碼可以看出，可以先使用Lambda的removeIf刪除多余的數(shù)據，再進行循環(huán)是一種正確操作集合的方式。
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 循環(huán)中刪除數(shù)據非安全。
Stream 循環(huán)的正確方式：
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過濾掉無用的數(shù)據，再進行遍歷也是一種安全的操作集合的方式。
6.5、小結
我們不能在遍歷中使用集合map.remove()來刪除數(shù)據，這是非安全的操作方式，但我們可以使用迭代器的iterator.remove()的方法來刪除數(shù)據，這是安全的刪除集合的方式。同樣的我們也可以使用 Lambda 中的removeIf來提前刪除數(shù)據，或者是使用 Stream 中的filter過濾掉要刪除的數(shù)據進行循環(huán)，這樣都是安全的，當然我們也可以在for循環(huán)前刪除數(shù)據在遍歷也是線程安全的。
七、總結
本文我們講了 HashMap 4 種遍歷方式：迭代器、for、lambda、stream，以及具體的 7 種遍歷方法，綜合性能和安全性來看，我們應該盡量使用迭代器（Iterator）來遍歷EntrySet的遍歷方式來操作 Map 集合，這樣就會既安全又高效了。
以上就是淺談HashMap中7種遍歷方式的性能分析的詳細內容，更多關于HashMap 遍歷性能分析的資料請關注腳本之家其它相關文章！
相關文章
這篇文章主要介紹了Java之字符串轉換成Java對象方式，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2023-07-07
SPI是一種使軟件框架或庫更加模塊化、可擴展和可維護的有效方法。通過遵循“開閉原則”，?SPI?確保了系統(tǒng)的穩(wěn)定性和靈活性，從而滿足了不斷變化的業(yè)務需求，這篇文章主要介紹了SPI機制在JDK與Spring?Boot中的應用,需要的朋友可以參考下2023-09-09
這篇文章介紹了Java結合JS實現(xiàn)URL編碼與解碼的方法，文中通過示例代碼介紹的非常詳細。對大家的學習或工作具有一定的參考借鑒價值，需要的朋友可以參考下2022-03-03
這篇文章主要介紹了mybatis實現(xiàn)批量修改-xml方式，具有很好的參考價值，希望對大家有所幫助。如有錯誤或未考慮完全的地方，望不吝賜教2021-11-11
在實際的項目開發(fā)中,我們往往需要根據不同的環(huán)境做出不同的配置,例如：在開發(fā)環(huán)境下,我們會使用內存數(shù)據庫以便快速啟動服務并進行開發(fā)調試,在test環(huán)境、生產環(huán)境,會使用對應環(huán)境的數(shù)據庫,這篇文章主要介紹了SpringBoot中的條件裝配方法,需要的朋友可以參考下2024-08-08
IDEA導入eclipse項目并且部署到tomcat的步驟詳解
這篇文章主要給大家介紹了關于IDEA導入eclipse項目并且部署到tomcat的相關資料，文中通過圖文介紹的非常詳細，對大家的學習或者工作具有一定的參考學習價值，需要的朋友們下面來一起學習學習吧2019-02-02
本文將對比《青春有你2》和《創(chuàng)造營2020》全體小姐姐，鑒于兩個節(jié)目的數(shù)據采集和處理過程基本相似，在使用Python做數(shù)據爬蟲采集的章節(jié)中將只以《創(chuàng)造營2020》為例做詳細介紹。感興趣的同學可以照貓畫虎去實操一下《青春有你2》的數(shù)據爬蟲采集，需要的朋友可以參考下2021-04-04
這篇文章主要介紹了java寫卷積神經網絡(CupCnn簡介)，小編覺得挺不錯的，現(xiàn)在分享給大家，也給大家做個參考。一起跟隨小編過來看看吧2018-04-04
IoC是一種讓服務消費者不直接依賴于服務提供者的組件設計方式，是一種減少類與類之間依賴的設計原則。下面通過本文給大家分享spring中ioc的概念，感興趣的朋友一起看看吧2021-09-09
在許多加密和安全應用中,生成隨機的密鑰是至關重要的一步,密鑰通常以16進制形式表示,并且具有特定的長度,在這篇博客中,我們將探討如何使用Java生成一個32位長度的16進制密鑰,并展示詳細的代碼示例和運行結果,需要的朋友可以參考下2024-08-08