1. Map 遍历的基础准备

Map<String, String> map = new HashMap<>();
map.put("A", "Apple");
map.put("B", "Banana");
map.put("C", "Cherry");

2. 七种遍历方式详解

2.1 entrySet + for-each（推荐）

最经典、最通用的方式。

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

优点：同时获取 key 和 value，性能最佳（只遍历一次）
缺点：代码稍长（但可读性好）

2.2 keySet + for-each（不推荐）

只取 key，再通过 key 获取 value。

for (String key : map.keySet()) {
    String value = map.get(key);
    System.out.println(key + " -> " + value);
}

缺点：需要两次查找（迭代 + get），HashMap 中性能约为 entrySet 的一半。

2.3 只遍历 value

for (String value : map.values()) {
    System.out.println(value);
}

适用场景：只需要 value，不需要 key。

2.4 Iterator + entrySet（适合删除操作）

Iterator<Map.Entry<String, String>> iter = map.entrySet().iterator();
while (iter.hasNext()) {
    Map.Entry<String, String> entry = iter.next();
    if ("B".equals(entry.getKey())) {
        iter.remove();  // 安全删除
    }
}

优点：遍历过程中可以安全删除元素。

2.5 forEach (Java 8+ Lambda)

map.forEach((key, value) -> System.out.println(key + " -> " + value));

优点：代码简洁优雅
缺点：不能修改外部非 final 变量（需要变通），不支持 break/return 提前终止（必须抛出异常）。

2.6 Stream API（函数式处理）

map.entrySet().stream()
    .filter(e -> e.getKey().startsWith("A"))
    .forEach(e -> System.out.println(e.getKey() + " -> " + e.getValue()));

适用场景：需要链式过滤、映射、聚合等操作。

2.7 仅 JDK 8+ 的 compute / merge 等（函数式计算）

虽然不属于“遍历”，但适用于边遍历边计算新值。

map.replaceAll((key, value) -> value.toUpperCase());

3. 性能对比（HashMap 测试）

测试环境：JDK 17, HashMap<String,String>, 100万条目，平均取三次。

4. 并发场景下的遍历

4.1 ConcurrentHashMap

ConcurrentHashMap<String, String> cmap = new ConcurrentHashMap<>();
// 使用与 HashMap 相同的遍历方式，但弱一致性
cmap.forEach((k, v) -> System.out.println(k));

4.2 遍历时修改（避免 ConcurrentModificationException）

• 普通 HashMap：只能用 Iterator.remove()
• ConcurrentHashMap：支持安全遍历，但无法保证立即看到最新数据

// 错误示范（会抛异常）
for (String key : map.keySet()) {
    if (condition) map.remove(key);
}

// 正确方式：Iterator 删除
Iterator<Map.Entry<String,String>> it = map.entrySet().iterator();
while(it.hasNext()){
    if(condition) it.remove();
}

5. 最佳实践总结

6. 常见误区与注意点

1. 不要在 for-each 中直接 map.remove() → 会抛 ConcurrentModificationException
2. keySet + get 性能差 → 尽量使用 entrySet
3. Lambda forEach 无法 break → 需要用 Stream.findFirst() 或普通循环
4. TreeMap / LinkedHashMap 的遍历顺序不同（默认排序 / 插入顺序），但遍历写法一样

7. 完整示例代码

public class MapLoopDemo {
    public static void main(String[] args) {
        Map<String, String> map = new HashMap<>();
        map.put("Java", "17");
        map.put("Python", "3.11");
        map.put("Go", "1.20");

        // 1. entrySet + for-each
        System.out.println("=== entrySet ===");
        for (var entry : map.entrySet()) {
            System.out.println(entry.getKey() + " : " + entry.getValue());
        }

        // 2. Java 8 forEach
        System.out.println("=== forEach Lambda ===");
        map.forEach((k, v) -> System.out.println(k + " : " + v));

        // 3. Stream 过滤
        System.out.println("=== Stream filter ===");
        map.entrySet().stream()
            .filter(e -> e.getKey().length() > 3)
            .forEach(e -> System.out.println(e.getKey()));
    }
}

结语

Java Map 循环没有“唯一正确”的方式，而是应根据可读性、性能、功能需求（删除/中断/并发）做出选择。日常开发中，entrySet + for-each 或 forEach Lambda 足以覆盖 90% 的场景；遇到复杂数据处理，优先考虑 Stream；需要遍历中删除，务必使用 Iterator。

掌握这七种方式，就能轻松应对所有 Map 遍历场景。

原创博主：Little Tomato
博主原文链接：https://www.ltomato.com/article/2054121200870891522