如何高效的遍歷Map？你常用的不一定是最快的

SnailsCoffee發表於2021-04-29

微信公眾號：大黃奔跑
關注我，可瞭解更多有趣的面試相關問題。

寫在之前

如文章標題所言，遍歷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 的程式設計師，下期見。

相關文章