如何有效地迭代 Java Map 中的每个条目？

https://stackoverflow.com/questions/46898

09-06-2019
|

题

如果我有一个对象实现 Map Java 中的接口，我希望迭代其中包含的每一对，遍历映射的最有效方法是什么？

元素的顺序是否取决于接口的特定映射实现？

解决方案

Map<String, String> map = ...
for (Map.Entry<String, String> entry : map.entrySet()) {
    System.out.println(entry.getKey() + "/" + entry.getValue());
}

其他提示

为了总结其他答案并将它们与我所知道的结合起来，我找到了 10 种主要方法来做到这一点（见下文）。另外，我编写了一些性能测试（见下面的结果）。例如，如果我们想求映射中所有键和值的总和，我们可以这样写：

使用 迭代器 和 地图入口

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

使用 foreach 和 地图入口

long i = 0;
for (Map.Entry<Integer, Integer> pair : map.entrySet()) {
    i += pair.getKey() + pair.getValue();
}

使用 对于每个 从 Java 8

final long[] i = {0};
map.forEach((k, v) -> i[0] += k + v);

使用 按键集 和 foreach

long i = 0;
for (Integer key : map.keySet()) {
    i += key + map.get(key);
}

使用 按键集 和 迭代器

long i = 0;
Iterator<Integer> itr2 = map.keySet().iterator();
while (itr2.hasNext()) {
    Integer key = itr2.next();
    i += key + map.get(key);
}

使用为了和 地图入口

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

使用 Java 8 流媒体接口

final long[] i = {0};
map.entrySet().stream().forEach(e -> i[0] += e.getKey() + e.getValue());

使用 Java 8 流API并行

final long[] i = {0};
map.entrySet().stream().parallel().forEach(e -> i[0] += e.getKey() + e.getValue());

使用 迭代映射 的 Apache Collections

long i = 0;
MapIterator<Integer, Integer> it = iterableMap.mapIterator();
while (it.hasNext()) {
    i += it.next() + it.getValue();
}

使用 可变映射 Eclipse (CS) 集合

final long[] i = {0};
mutableMap.forEachKeyValue((key, value) -> {
    i[0] += key + value;
});

性能测试 （模式 = AverageTime，系统 = Windows 8.1 64 位、Intel i7-4790 3.60 GHz、16 GB）

对于小地图（100 个元素），得分 0.308 是最好的

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

对于 10000 个元素的地图，得分 37.606 是最好的

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

对于具有 100000 个元素的地图，分数 1184.767 是最好的

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

图表（性能测试取决于地图大小）

表（性能测试取决于地图大小）

          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

所有测试均已开启 GitHub.

在 Java 8 中，您可以使用新的 lambda 功能干净快速地完成此操作：

 Map<String,String> map = new HashMap<>();
 map.put("SomeKey", "SomeValue");
 map.forEach( (k,v) -> [do something with key and value] );

 // such as
 map.forEach( (k,v) -> System.out.println("Key: " + k + ": Value: " + v));

的类型 k 和 v 将由编译器推断，无需使用 Map.Entry 不再了。

十分简单！

是的，顺序取决于具体的 Map 实现。

@ScArcher2 具有更优雅的 Java 1.5 语法. 。在 1.4 中，我会做这样的事情：

Iterator entries = myMap.entrySet().iterator();
while (entries.hasNext()) {
  Entry thisEntry = (Entry) entries.next();
  Object key = thisEntry.getKey();
  Object value = thisEntry.getValue();
  // ...
}

迭代映射的典型代码是：

Map<String,Thing> map = ...;
for (Map.Entry<String,Thing> entry : map.entrySet()) {
    String key = entry.getKey();
    Thing thing = entry.getValue();
    ...
}

HashMap 是规范的映射实现，并且不做出保证（或者如果没有对其执行变异操作，则它不应该改变顺序）。 SortedMap 将根据键的自然顺序返回条目，或者 Comparator, ，如果提供的话。 LinkedHashMap 将按照插入顺序或访问顺序返回条目，具体取决于它的构造方式。 EnumMap 按键的自然顺序返回条目。

（更新：我认为这不再是真的。）笔记， IdentityHashMap entrySet 迭代器目前有一个特殊的实现，它返回相同的值 Map.Entry 中每个项目的实例 entrySet！然而，每次新的迭代器都会推进 Map.Entry 已更新。

使用迭代器和泛型的示例：

Iterator<Map.Entry<String, String>> entries = myMap.entrySet().iterator();
while (entries.hasNext()) {
  Map.Entry<String, String> entry = entries.next();
  String key = entry.getKey();
  String value = entry.getValue();
  // ...
}

这是一个由两部分组成的问题：

如何迭代 Map 的条目 - @ScArcher2 有回答了非常完美。

迭代的顺序是什么 - 如果您只是使用 Map, ，那么严格来说，有 没有订购保证. 。因此，您不应该真正依赖任何实现给出的顺序。但是，那 SortedMap 接口扩展 Map 并准确提供您正在寻找的内容 - 实现将给出一致的排序顺序。

NavigableMap 是另一个有用的扩展 - 这是一个 SortedMap 具有根据键集中的有序位置查找条目的附加方法。因此，这可能可以消除首先进行迭代的需要 - 您也许能够找到特定的 entry 你在使用之后 higherEntry, lowerEntry, ceilingEntry, ，或者 floorEntry 方法。这 descendingMap 方法甚至给你一个明确的方法 反转遍历顺序.

有多种方法可以迭代地图。

下面是对存储在映射中的常见数据集的性能比较，通过在映射中存储一百万个键值对并将迭代映射。

1）使用 entrySet() 在每个循环中

for (Map.Entry<String,Integer> entry : testMap.entrySet()) {
    entry.getKey();
    entry.getValue();
}

50毫秒

2）使用 keySet() 在每个循环中

for (String key : testMap.keySet()) {
    testMap.get(key);
}

76毫秒

3）使用 entrySet() 和迭代器

Iterator<Map.Entry<String,Integer>> itr1 = testMap.entrySet().iterator();
while(itr1.hasNext()) {
    Map.Entry<String,Integer> entry = itr1.next();
    entry.getKey();
    entry.getValue();
}

50毫秒

4）使用 keySet() 和迭代器

Iterator itr2 = testMap.keySet().iterator();
while(itr2.hasNext()) {
    String key = itr2.next();
    testMap.get(key);
}

75毫秒

我已经提到过 this link.

正确的方法是使用已接受的答案，因为它是最有效的。我发现下面的代码看起来更干净一些。

for (String key: map.keySet()) {
   System.out.println(key + "/" + map.get(key));
}

仅供参考，您还可以使用 map.keySet() 和 map.values() 如果您只对地图的键/值感兴趣而不是其他。

和日食系列（以前 GS系列），您可以使用 forEachKeyValue 方法映射可迭代接口，由 MutableMap 和 ImmutableMap 接口及其实现继承。

final MutableBag<String> result = Bags.mutable.empty();
MutableMap<Integer, String> map = Maps.mutable.of(1, "One", 2, "Two", 3, "Three");
map.forEachKeyValue(new Procedure2<Integer, String>()
{
    public void value(Integer key, String value)
    {
        result.add(key + value);
    }
});
Assert.assertEquals(Bags.mutable.of("1One", "2Two", "3Three"), result);

使用Java 8 lambda语法，您可以编写如下代码：

MutableBag<String> result = Bags.mutable.empty();
MutableMap<Integer, String> map = Maps.mutable.of(1, "One", 2, "Two", 3, "Three");
map.forEachKeyValue((key, value) -> result.add(key + value));
Assert.assertEquals(Bags.mutable.of("1One", "2Two", "3Three"), result);

笔记： 我是 Eclipse Collections 的提交者。

理论上，最有效的方法将取决于 Map 的实现。执行此操作的官方方法是调用 map.entrySet(), ，它返回一组 Map.Entry, ，每个都包含一个键和一个值（entry.getKey() 和 entry.getValue()).

在特殊的实现中，是否使用可能会有所不同 map.keySet(), map.entrySet() 或者是其他东西。但我想不出为什么有人会这样写。最有可能的是，你所做的事情对性能没有影响。

是的，顺序将取决于实现 - 以及（可能）插入顺序和其他难以控制的因素。

[编辑]我写的 valueSet() 本来但当然 entrySet() 实际上就是答案。

Java 8：

您可以使用 lambda 表达式：

myMap.entrySet().stream().forEach((entry) -> {
    Object currentKey = entry.getKey();
    Object currentValue = entry.getValue();
});

欲了解更多信息，请关注这.

用 Java 1.4 试试这个：

for( Iterator entries = myMap.entrySet().iterator(); entries.hasNext();){

  Entry entry = (Entry) entries.next();

  System.out.println(entry.getKey() + "/" + entry.getValue());

  //...
}

和 爪哇8

map.forEach((k, v) -> System.out.println((k + ":" + v)));

爪哇8

我们有 forEach 方法接受一个拉姆达表达式. 。我们还得到了溪流蜜蜂。考虑一张地图：

Map<String,String> sample = new HashMap<>();
sample.put("A","Apple");
sample.put("B", "Ball");

迭代键：

sample.keySet().forEach((k) -> System.out.println(k));

迭代值：

sample.values().forEach((v) -> System.out.println(v));

迭代条目（使用 forEach 和 Streams）：

sample.forEach((k,v) -> System.out.println(k + ":" + v)); 
sample.entrySet().stream().forEach((entry) -> {
            Object currentKey = entry.getKey();
            Object currentValue = entry.getValue();
            System.out.println(currentKey + ":" + currentValue);
        });

流的优点是，如果我们愿意，它们可以轻松并行化。我们只需要使用 parallelStream() 代替 stream() 多于。

forEachOrdered 与 forEach 与溪流？这 forEach 不遵循遭遇顺序（如果已定义）并且本质上是不确定的，其中 forEachOrdered 做。所以 forEach 不保证订单会被保留。另请检查这了解更多。

拉姆达 表达式 Java 8

在 Java 1.8 (Java 8) 中，通过使用这变得更加容易 对于每个 聚合操作中的方法（流操作）看起来类似于迭代器 可迭代 界面。

只需将以下语句复制粘贴到您的代码中并重命名 哈希映射 变量来自嗯到您的 HashMap 变量以打印出键值对。

HashMap<Integer,Integer> hm = new HashMap<Integer, Integer>();
/*
 *     Logic to put the Key,Value pair in your HashMap hm
 */

// Print the key value pair in one line.

hm.forEach((k, v) -> System.out.println("key: " + k + " value:" + v));

// Just copy and paste above line to your code.

下面是我尝试使用的示例代码 拉姆达表达式. 。这东西太酷了。一定要试。

HashMap<Integer, Integer> hm = new HashMap<Integer, Integer>();
    Random rand = new Random(47);
    int i = 0;
    while(i < 5) {
        i++;
        int key = rand.nextInt(20);
        int value = rand.nextInt(50);
        System.out.println("Inserting key: " + key + " Value: " + value);
        Integer imap = hm.put(key, value);
        if( imap == null) {
            System.out.println("Inserted");
        } else {
            System.out.println("Replaced with " + imap);
        }               
    }

    hm.forEach((k, v) -> System.out.println("key: " + k + " value:" + v));

Output:

Inserting key: 18 Value: 5
Inserted
Inserting key: 13 Value: 11
Inserted
Inserting key: 1 Value: 29
Inserted
Inserting key: 8 Value: 0
Inserted
Inserting key: 2 Value: 7
Inserted
key: 1 value:29
key: 18 value:5
key: 2 value:7
key: 8 value:0
key: 13 value:11

也可以使用 分离器 对于相同的。

Spliterator sit = hm.entrySet().spliterator();

更新

包括 Oracle 文档的文档链接。更多关于 拉姆达 去这个关联并且必须阅读聚合运算对于 Spliterator 转到此关联.

在 Map 中可以迭代 keys 和/或 values 和/或 both (e.g., entrySet) 取决于一个人的兴趣_比如：

1.) 迭代 keys -> keySet() 地图的：

Map<String, Object> map = ...;

for (String key : map.keySet()) {
    //your Business logic...
}

2.) 迭代 values -> values() 地图的：

for (Object value : map.values()) {
    //your Business logic...
}

3.) 迭代 both -> entrySet() 地图的：

for (Map.Entry<String, Object> entry : map.entrySet()) {
    String key = entry.getKey();
    Object value = entry.getValue();
    //your Business logic...
}

此外，有 3 种不同的方法来迭代 HashMap。它们如下_

//1.
for (Map.Entry entry : hm.entrySet()) {
    System.out.print("key,val: ");
    System.out.println(entry.getKey() + "," + entry.getValue());
}

//2.
Iterator iter = hm.keySet().iterator();
while(iter.hasNext()) {
    Integer key = (Integer)iter.next();
    String val = (String)hm.get(key);
    System.out.println("key,val: " + key + "," + val);
}

//3.
Iterator it = hm.entrySet().iterator();
while (it.hasNext()) {
    Map.Entry entry = (Map.Entry) it.next();
    Integer key = (Integer)entry.getKey();
    String val = (String)entry.getValue();
    System.out.println("key,val: " + key + "," + val);
}

Java 8 最紧凑：

map.entrySet().forEach(System.out::println);

public class abcd{
    public static void main(String[] args)
    {
       Map<Integer, String> testMap = new HashMap<Integer, String>();
        testMap.put(10, "a");
        testMap.put(20, "b");
        testMap.put(30, "c");
        testMap.put(40, "d");
        for (Integer key:testMap.keySet()) {
            String value=testMap.get(key);
            System.out.println(value);
        }
    }
}

或者

public class abcd {
    public static void main(String[] args)
    {
       Map<Integer, String> testMap = new HashMap<Integer, String>();
        testMap.put(10, "a");
        testMap.put(20, "b");
        testMap.put(30, "c");
        testMap.put(40, "d");
        for (Entry<Integer, String> entry : testMap.entrySet()) {
            Integer key=entry.getKey();
            String value=entry.getValue();
        }
    }
}

如果您有一个通用的无类型映射，您可以使用：

Map map = new HashMap();
for (Map.Entry entry : ((Set<Map.Entry>) map.entrySet())) {
    System.out.println(entry.getKey() + "/" + entry.getValue());
}

    Iterator iterator = map.entrySet().iterator();
    while (iterator.hasNext()) {
        Map.Entry element = (Map.Entry)it.next();
        LOGGER.debug("Key: " + element.getKey());
        LOGGER.debug("value: " + element.getValue());    
    }

您可以使用泛型来做到这一点：

Map<Integer, Integer> map = new HashMap<Integer, Integer>();
Iterator<Map.Entry<Integer, Integer>> entries = map.entrySet().iterator();
while (entries.hasNext()) {
    Map.Entry<Integer, Integer> entry = entries.next();
    System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());
}

使用Java 8：

map.entrySet().forEach(entry -> System.out.println(entry.getValue()));

           //Functional Oprations
            Map<String, String> mapString = new HashMap<>();
            mapString.entrySet().stream().map((entry) -> {
                String mapKey = entry.getKey();
                return entry;
            }).forEach((entry) -> {
                String mapValue = entry.getValue();
            });

            //Intrator
            Map<String, String> mapString = new HashMap<>();
            for (Iterator<Map.Entry<String, String>> it = mapString.entrySet().iterator(); it.hasNext();) {
                Map.Entry<String, String> entry = it.next();
                String mapKey = entry.getKey();
                String mapValue = entry.getValue();
            }

            //Simple for loop
            Map<String, String> mapString = new HashMap<>();
            for (Map.Entry<String, String> entry : mapString.entrySet()) {
                String mapKey = entry.getKey();
                String mapValue = entry.getValue();

            }

排序始终取决于具体的地图实现。使用 Java 8，您可以使用以下任一方法：

map.forEach((k,v) -> { System.out.println(k + ":" + v); });

或者：

map.entrySet().forEach((e) -> {
            System.out.println(e.getKey() + " : " + e.getValue());
        });

结果将是相同的（相同的顺序）。EntrySet 由地图支持，因此您将获得相同的顺序。第二个很方便，因为它允许您使用 lambda，例如如果您只想打印大于 5 的 Integer 对象：

map.entrySet()
    .stream()
    .filter(e-> e.getValue() > 5)
    .forEach(System.out::println);

下面的代码显示了 LinkedHashMap 和普通 HashMap 的迭代（示例）。您会发现顺序有所不同：

public class HMIteration {


    public static void main(String[] args) {
        Map<Object, Object> linkedHashMap = new LinkedHashMap<>();
        Map<Object, Object> hashMap = new HashMap<>();

        for (int i=10; i>=0; i--) {
            linkedHashMap.put(i, i);
            hashMap.put(i, i);
        }

        System.out.println("LinkedHashMap (1): ");
        linkedHashMap.forEach((k,v) -> { System.out.print(k + " (#="+k.hashCode() + "):" + v + ", "); });

        System.out.println("\nLinkedHashMap (2): ");

        linkedHashMap.entrySet().forEach((e) -> {
            System.out.print(e.getKey() + " : " + e.getValue() + ", ");
        });


        System.out.println("\n\nHashMap (1): ");
        hashMap.forEach((k,v) -> { System.out.print(k + " (#:"+k.hashCode() + "):" + v + ", "); });

        System.out.println("\nHashMap (2): ");

        hashMap.entrySet().forEach((e) -> {
            System.out.print(e.getKey() + " : " + e.getValue() + ", ");
        });
    }
}

LinkedHashMap（一）：

10 (#=10):10, 9 (#=9):9, 8 (#=8):8, 7 (#=7):7, 6 (#=6):6, 5 (#=5):5, 4 (#=4):4, 3 (#=3):3, 2 (#=2):2, 1 (#=1):1, 0 (#=0):0,

LinkedHashMap（二）：

10 : 10, 9 : 9, 8 : 8, 7 : 7, 6 : 6, 5 : 5, 4 : 4, 3 : 3, 2 : 2, 1 : 1, 0 : 0,

哈希映射（一）：

0 (#:0):0, 1 (#:1):1, 2 (#:2):2, 3 (#:3):3, 4 (#:4):4, 5 (#:5):5, 6 (#:6):6, 7 (#:7):7, 8 (#:8):8, 9 (#:9):9, 10 (#:10):10,

哈希映射（2）：

0 : 0, 1 : 1, 2 : 2, 3 : 3, 4 : 4, 5 : 5, 6 : 6, 7 : 7, 8 : 8, 9 : 9, 10 : 10,

Map 的有效迭代解决方案是从 Java 5 到 Java 7 的“foreach”循环。这里是：

for (String key : phnMap.keySet()) {
    System.out.println("Key: " + key + " Value: " + phnMap.get(key));
}

从 Java 8 开始，您可以使用 lambda 表达式来迭代 Map。这是一个增强的“forEach”

phnMap.forEach((k,v) -> System.out.println("Key: " + k + " Value: " + v));

如果你想为 lambda 编写一个条件，你可以这样写：

phnMap.forEach((k,v)->{
    System.out.println("Key: " + k + " Value: " + v);
    if("abc".equals(k)){
        System.out.println("Hello abc");
    }
});

是的，正如许多人同意的那样，这是迭代的最佳方法 Map.

但还是有机会抛出 nullpointerexception 如果地图是 null. 。别忘了放 null 。报到。

                                                 |
                                                 |
                                         - - - -
                                       |
                                       |
for (Map.Entry<String, Object> entry : map.entrySet()) {
    String key = entry.getKey();
    Object value = entry.getValue();
}

package com.test;

import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

public class Test {

    public static void main(String[] args) {
        Map<String, String> map = new HashMap<String, String>();
        map.put("ram", "ayodhya");
        map.put("krishan", "mathura");
        map.put("shiv", "kailash");

        System.out.println("********* Keys *********");
        Set<String> keys = map.keySet();
        for (String key : keys) {
            System.out.println(key);
        }

        System.out.println("********* Values *********");
        Collection<String> values = map.values();
        for (String value : values) {
            System.out.println(value);
        }

        System.out.println("***** Keys and Values (Using for each loop) *****");
        for (Map.Entry<String, String> entry : map.entrySet()) {
            System.out.println("Key: " + entry.getKey() + "\t Value: "
                    + entry.getValue());
        }

        System.out.println("***** Keys and Values (Using while loop) *****");
        Iterator<Entry<String, String>> entries = map.entrySet().iterator();
        while (entries.hasNext()) {
            Map.Entry<String, String> entry = (Map.Entry<String, String>) entries
                    .next();
            System.out.println("Key: " + entry.getKey() + "\t Value: "
                    + entry.getValue());
        }

        System.out
                .println("** Keys and Values (Using java 8 using lambdas )***");
        map.forEach((k, v) -> System.out
                .println("Key: " + k + "\t value: " + v));
    }
}

有很多方法可以做到这一点。下面是几个简单的步骤：

假设您有一张类似以下的地图：

Map<String, Integer> m = new HashMap<String, Integer>();

然后您可以执行类似下面的操作来迭代地图元素。

// ********** Using an iterator ****************
Iterator<Entry<String, Integer>> me = m.entrySet().iterator();
while(me.hasNext()){
    Entry<String, Integer> pair = me.next();
    System.out.println(pair.getKey() + ":" + pair.getValue());
}

// *********** Using foreach ************************
for(Entry<String, Integer> me : m.entrySet()){
    System.out.println(me.getKey() + " : " + me.getValue());
}

// *********** Using keySet *****************************
for(String s : m.keySet()){
    System.out.println(s + " : " + m.get(s));
}

// *********** Using keySet and iterator *****************
Iterator<String> me = m.keySet().iterator();
while(me.hasNext()){
    String key = me.next();
    System.out.println(key + " : " + m.get(key));
}

许可以下： CC-BY-SA 和归因

不隶属于 StackOverflow