微信公眾號：大黃奔跑
關注我，可了解更多有趣的面試相關問題。
寫在之前
如文章標題所言，遍歷Map是開發過程中比較常見的行為，實現的方式也有多種方式，本文帶領大家一起看看更加高效的遍歷 Map。
『茴』的十種寫法
首先一起來看看，有哪些遍歷 Map 的方式
1. 利用 iterator 和 Map.Entry
long i = 0;
Iterator<Map.Entry<Integer, Integer>>
it = map.entrySet().iterator();
while (it.hasNext()) {
Map.Entry<Integer, Integer> pair = it.next();
i += pair.getKey() + pair.getValue();
}
2. 利用 foreach 和Map.Entry
long i = 0;
for (Map.Entry<Integer, Integer> pair
: map.entrySet()) {
i += pair.getKey() + pair.getValue();
}
3. 利用 Java 8中的foreach
這種應該算是比較常見的使用方式，也是比較容易理解的
final long[] i = {0};
map.forEach((k, v) -> i[0] += k + v);
4. 利用keySet 和 foreach
keySet： 獲取 map 中所有的 key，然后依次遍歷每個 key。
long i = 0;
for (Integer key : map.keySet()) {
i += key + map.get(key);
}
5. 利用keySet and iterator
long i = 0;
Iterator<Integer> itr2 = map.keySet().iterator();
while (itr2.hasNext()) {
Integer key = itr2.next();
i += key + map.get(key);
}
6. 利用for循環和Map.Entry
long i = 0;
for (Iterator<Map.Entry<Integer, Integer>>
entries = map.entrySet().iterator(); entries.hasNext(); ) {
Map.Entry<Integer, Integer> entry = entries.next();
i += entry.getKey() + entry.getValue();
}
7. 利用 Java8 的Stream API
這種是我平時開發中用的最多的方式，簡單通俗易懂。
但是其性能如何呢？后續待揭秘。
final long[] i = {0};
map.entrySet().stream()
.forEach(e -> i[0] += e.getKey()
+ e.getValue());
8. 利用Java8 中的 Stream API parallel
不知道有多少人用過 Java8 中的 parallel模式，本質是一種並行處理方式。
性能如何？稍后揭曉。
final long[] i = {0};
map.entrySet().stream().parallel()
.forEach(e -> i[0] += e.getKey() + e.getValue());
9. 利用 Apache 包的 IterableMap of
不行就找找外援試試？
long i = 0;
MapIterator<Integer, Integer> it
= iterableMap.mapIterator();
while (it.hasNext()) {
i += it.next() + it.getValue();
}
10. 利用Eclipse (CS) collections 中的MutableMap
final long[] i = {0};
mutableMap.forEachKeyValue((key, value)
-> {i[0] += key + value;
});
性能測試
測試環境如下：Intel i7-4790 3.60 GHz, 16 GB
場景1：小數據集
測試集為小的Map集合（大約100個元素），各個方法耗時如下：
Benchmark Mode Cnt Score Error Units
test3_UsingForEachAndJava8 avgt 10 0.308 ± 0.021 µs/op
test10_UsingEclipseMap avgt 10 0.309 ± 0.009 µs/op
test1_UsingWhileAndMapEntry avgt 10 0.380 ± 0.014 µs/op
test6_UsingForAndIterator avgt 10 0.387 ± 0.016 µs/op
test2_UsingForEachAndMapEntry avgt 10 0.391 ± 0.023 µs/op
test7_UsingJava8StreamApi avgt 10 0.510 ± 0.014 µs/op
test9_UsingApacheIterableMap avgt 10 0.524 ± 0.008 µs/op
test4_UsingKeySetAndForEach avgt 10 0.816 ± 0.026 µs/op
test5_UsingKeySetAndIterator avgt 10 0.863 ± 0.025 µs/op
test8_UsingJava8StreamApiParallel avgt 10 5.552 ± 0.185 µs/op
從結果看出，在數據量比較小時，利用 Java 8中的foreach 暫時領先。
場景2：中等數據集
測試集為元素數據量 1000 的 Map 集合，測試結果如下：
Benchmark Mode Cnt Score Error Units
test10_UsingEclipseMap avgt 10 37.606 ± 0.790 µs/op
test3_UsingForEachAndJava8 avgt 10 50.368 ± 0.887 µs/op
test6_UsingForAndIterator avgt 10 50.332 ± 0.507 µs/op
test2_UsingForEachAndMapEntry avgt 10 51.406 ± 1.032 µs/op
test1_UsingWhileAndMapEntry avgt 10 52.538 ± 2.431 µs/op
test7_UsingJava8StreamApi avgt 10 54.464 ± 0.712 µs/op
test4_UsingKeySetAndForEach avgt 10 79.016 ± 25.345 µs/op
test5_UsingKeySetAndIterator avgt 10 91.105 ± 10.220 µs/op
test8_UsingJava8StreamApiParallel avgt 10 112.511 ± 0.365 µs/op
test9_UsingApacheIterableMap avgt 10 125.714 ± 1.935 µs/op
從結果集合看，在中等數據量情況下，外援 Eclipse (CS) collections 中的 MutableMap 表現最為優異，勇得第一。
其次為 Java 8中的 foreach，位列第二。
場景3：大數據集
測試集為元素數據量 100000（十萬級別） 的 Map 集合，測試結果如下：
Benchmark Mode Cnt Score Error Units
test1_UsingWhileAndMapEntry avgt 10 1184.767 ± 332.968 µs/op
test10_UsingEclipseMap avgt 10 1191.735 ± 304.273 µs/op
test2_UsingForEachAndMapEntry avgt 10 1205.815 ± 366.043 µs/op
test6_UsingForAndIterator avgt 10 1206.873 ± 367.272 µs/op
test8_UsingJava8StreamApiParallel avgt 10 1485.895 ± 233.143 µs/op
test5_UsingKeySetAndIterator avgt 10 1540.281 ± 357.497 µs/op
test4_UsingKeySetAndForEach avgt 10 1593.342 ± 294.417 µs/op
test3_UsingForEachAndJava8 avgt 10 1666.296 ± 126.443 µs/op
test7_UsingJava8StreamApi avgt 10 1706.676 ± 436.867 µs/op
test9_UsingApacheIterableMap avgt 10 3289.866 ± 1445.564 µs/op
利用 iterator 和 Map.Entry 【方法1】穩居第一，領先 第二名差不多7s。
第二名為 Eclipse (CS) collections 中的 MutableMap 位列第二，在大數據量下表現表現比較出色。
指的注意的是之前在小數據量下表現比較出色的 Java 8中的 foreach，排名卻比較靠后，但是仍然超過了利用 Java8 的Stream API。
其中還有另一個現象：利用並行模式計算的 Java8 中的 Stream API parallel，在大數據量時表現好於 foreach 和 stream api。
總結性能
下表為不同數據量情況下的各個方法性能表現
100 600 1100 1600 2100
test10 0.333 1.631 2.752 5.937 8.024
test3 0.309 1.971 4.147 8.147 10.473
test6 0.372 2.190 4.470 8.322 10.531
test1 0.405 2.237 4.616 8.645 10.707
test2 0.376 2.267 4.809 8.403 10.910
test7 0.473 2.448 5.668 9.790 12.125
test9 0.565 2.830 5.952 13.220 16.965
test4 0.808 5.012 8.813 13.939 17.407
test5 0.810 5.104 8.533 14.064 17.422
test8 5.173 12.499 17.351 24.671 30.403
在平時開發中，數據量都不算太大時，剖除外援而言， Java 8 中的 foreach 【方法3】，表現比較優異。而並行運算的 Stream API parallel【方法8】表現沒有想象中好，Stream API【方法7】表現中規中矩。
總結
主要羅列了多種遍歷 Map 的方式，每個實現方式都有各自的特點，有的人喜歡 foreach 的通俗易懂；有的人喜歡 stream 的干凈利落。
如果從性能來看，小數據量情況下：優先推薦使用 Java8 Foreach【方法3】。
大數據量情況下推薦 使用 iterator 和 Map.Entry【方法1】。
本文非原創文章，翻譯自stackoverflow 上的How do I efficiently iterate over each entry in a Java Map?問題答案之一。
原文地址為：(https://stackoverflow.com/questions/46898/how-do-i-efficiently-iterate-over-each-entry-in-a-java-map
也可以通過閱讀原文跳轉。
我是大黃，一個只會寫 HelloWorld 的程序員，下期見。