核心概念

Map 接口中的 forEach 方法是一个 终端操作，它接收一个 BiConsumer（二元消费者）函数式接口作为参数。BiConsumer 会接收两个参数：键和值,并对它们执行指定的操作。

方法签名：

void forEach(BiConsumer<? super K, ? super V> action);

• K: Map 的键类型。
• V: Map 的值类型。
• BiConsumer: 一个函数式接口，包含一个 accept(K key, V value) 方法,用于对键值对执行操作。

基本用法：Lambda 表达式

这是最常见、最简洁的用法，我们可以使用 Lambda 表达式来定义对每个键值对要执行的操作。

示例代码：

import java.util.HashMap;
import java.util.Map;
public class MapForEachExample {
    public static void main(String[] args) {
        // 创建一个 Map 并填充数据
        Map<String, Integer> studentScores = new HashMap<>();
        studentScores.put("Alice", 95);
        studentScores.put("Bob", 88);
        studentScores.put("Charlie", 76);
        studentScores.put("David", 99);
        System.out.println("--- 使用 Lambda 表达式遍历 Map ---");
        // 使用 forEach 遍历
        studentScores.forEach((key, value) -> {
            System.out.println("学生: " + key + ", 分数: " + value);
        });
    }
}

输出：

--- 使用 Lambda 表达式遍历 Map ---
学生: Alice, 分数: 95
学生: David, 分数: 99
学生: Charlie, 分数: 76
学生: Bob, 分数: 88

代码解析：

• studentScores.forEach(...)：调用 forEach 方法。
• (key, value) -> { ... }：这是一个 Lambda 表达式，它实现了 BiConsumer 接口。
  • key：代表 Map 中的每一个键。
  • value：代表与该键对应的值。
  • ->：是 Lambda 操作符,分隔参数列表和函数体。
  • { System.out.println(...) }：是我们对每个键值对执行的操作。

方法引用

forEach 中的操作仅仅是调用一个已经存在的方法，那么可以使用更简洁的 方法引用 语法。

示例代码：

假设我们有一个工具方法来打印信息：

import java.util.HashMap;
import java.util.Map;
public class MapForEachExample {
    // 一个静态方法，用于打印信息
    public static void printInfo(String key, Integer value) {
        System.out.println("Key: " + key + ", Value: " + value);
    }
    public static void main(String[] args) {
        Map<String, Integer> studentScores = new HashMap<>();
        studentScores.put("Alice", 95);
        studentScores.put("Bob", 88);
        System.out.println("--- 使用方法引用遍历 Map ---");
        // 使用方法引用
        studentScores.forEach(MapForEachExample::printInfo);
    }
}

输出：

--- 使用方法引用遍历 Map ---
Key: Alice, Value: 95
Key: Bob, Value: 88

代码解析：

• MapForEachExample::printInfo：这就是方法引用。
  • 它告诉 forEach：“对于每个键值对，请调用 MapForEachExample 这个类的 printInfo 方法，并将键作为第一个参数，值作为第二个参数传递过去。”
  • 这种方式比 Lambda 表达式更简洁，可读性更高,尤其是在方法逻辑已经很清晰的情况下。

在 Lambda 表达式中使用外部变量

forEach 循环可以访问并修改其所在作用域中的 final 或 effectively final（实际上等价于 final）的变量。

示例代码：

计算 Map 中所有分数的总和。

import java.util.HashMap;
import java.util.Map;
public class MapForEachSumExample {
    public static void main(String[] args) {
        Map<String, Integer> studentScores = new HashMap<>();
        studentScores.put("Alice", 95);
        studentScores.put("Bob", 88);
        studentScores.put("Charlie", 76);
        // 使用一个外部变量来累加总和
        int totalScore = 0;
        System.out.println("--- 计算总分 ---");
        studentScores.forEach((key, value) -> {
            // 在 Lambda 内部修改外部变量
            totalScore += value; 
        });
        System.out.println("所有学生的总分是: " + totalScore);
    }
}

输出：

--- 计算总分 ---
所有学生的总分是: 259

注意：

• 变量 totalScore 必须是 final 或者没有被重新赋值（即 effectively final），如果在 Lambda 体外对 totalScore 重新赋值（如 totalScore = 0;）,编译器会报错。
• 这种方式非常适合进行累加、计数等操作。

与传统遍历方式的对比

在 Java 8 之前，我们有以下几种遍历 Map 的方式,它们各有优缺点。

a. 使用 for-each 循环和 entrySet() (推荐的传统方式)

这是最传统且高效的方式之一。

System.out.println("--- 传统方式1: for-each + entrySet() ---");
for (Map.Entry<String, Integer> entry : studentScores.entrySet()) {
    String key = entry.getKey();
    Integer value = entry.getValue();
    System.out.println("学生: " + key + ", 分数: " + value);
}

优点：

• 高效：直接遍历 entrySet，避免了通过 key 再去查 value 的开销。
• 可读性好：代码意图明确。

b. 使用 for-each 循环和 keySet()

这种方式先获取所有键,再通过键去查找值。

System.out.println("--- 传统方式2: for-each + keySet() ---");
for (String key : studentScores.keySet()) {
    Integer value = studentScores.get(key);
    System.out.println("学生: " + key + ", 分数: " + value);
}

缺点：

• 效率较低：对于每个 key，studentScores.get(key) 都是一次额外的查找操作，时间复杂度接近 O(n²)。

c. 使用 Iterator

这种方式在遍历过程中需要安全地删除元素时非常有用。

System.out.println("--- 传统方式3: Iterator ---");
Iterator<Map.Entry<String, Integer>> iterator = studentScores.entrySet().iterator();
while (iterator.hasNext()) {
    Map.Entry<String, Integer> entry = iterator.next();
    System.out.println("学生: " + entry.getKey() + ", 分数: " + entry.getValue());
    // 如果需要删除元素，必须使用 iterator.remove()
    // iterator.remove();
}

forEach 的优缺点总结

优点

1. 代码简洁：一行代码即可完成遍历和操作,代码量大大减少。
2. 可读性强：forEach 的意图非常明确——“对每一个元素做某事”。
3. 函数式风格：符合现代函数式编程思想,可以将操作作为参数传递。
4. 不易出错：无需手动管理迭代器，避免了 ConcurrentModificationException（在单线程中，如果修改了 Map 结构，会抛出此异常）等问题（注意：forEach 在遍历过程中如果修改 Map 结构，同样会抛出此异常）。

缺点

1. 无法使用 break 或 continue：forEach 是一个内部迭代，你无法像 for 循环那样中途跳出或跳过某个元素，如果需要这种控制，必须使用传统的 for 循环。
2. 性能开销：对于极小型的 Map，Lambda 表达式可能会带来微小的性能开销（JIT 编译器通常会优化掉这部分开销），但在绝大多数应用场景下,这种差异可以忽略不计。
3. 修改 Map 结构：在 forEach 的 Lambda 表达式中直接调用 map.put() 或 map.remove() 会抛出 ConcurrentModificationException，如果需要在遍历时修改 Map，应使用 Iterator 的 remove() 方法。

总结与最佳实践

在现代 Java 开发中，Map.forEach() 应该是你的默认选择，它简洁、高效且符合现代编程范式，只有在你需要 break/continue 控制流，或者需要在遍历中安全地删除元素时，才考虑使用传统的 for 循环或 Iterator。