下面我将从最简单到最复杂,分不同场景详细介绍获取 Map value 的方法。

核心方法：get(key)

这是最基本、最常用的方法，用于根据指定的 key 获取对应的 value。

基本用法

import java.util.HashMap;
import java.util.Map;
public class GetMapValueExample {
    public static void main(String[] args) {
        // 1. 创建一个 Map 并存入数据
        Map<String, Integer> studentScores = new HashMap<>();
        studentScores.put("Alice", 95);
        studentScores.put("Bob", 88);
        studentScores.put("Charlie", 92);
        // 2. 使用 get(key) 方法获取 value
        Integer alicesScore = studentScores.get("Alice");
        System.out.println("Alice's score: " + alicesScore); // 输出: Alice's score: 95
        Integer bobsScore = studentScores.get("Bob");
        System.out.println("Bob's score: " + bobsScore); // 输出: Bob's score: 88
    }
}

处理 Key 不存在的情况（非常重要！）

如果使用 get(key) 方法去获取一个不存在的 key，它会返回 null，这可能会导致 NullPointerException，所以必须小心处理。

// 尝试获取一个不存在的 key
Integer davidsScore = studentScores.get("David");
// 如果不做判断，直接 davidsScore.intValue() 就会抛出 NullPointerException
System.out.println("David's score: " + davidsScore); // 输出: David's score: null

解决方案：

方案 A：使用 containsKey(key) 进行预检查

这是最传统、最安全的方式之一。

String keyToFind = "David";
if (studentScores.containsKey(keyToFind)) {
    Integer score = studentScores.get(keyToFind);
    System.out.println(keyToFind + "'s score: " + score);
} else {
    System.out.println(keyToFind + " not found in the map.");
}
// 输出: David not found in the map.

方案 B：使用 getOrDefault(key, defaultValue) (Java 8+ 推荐)

这是更现代、更简洁的方式，key 不存在，它会返回你指定的默认值，而不是 null。

// key "David" 不存在，则返回默认值 -1
Integer davidsScoreOrDefault = studentScores.getOrDefault("David", -1);
System.out.println("David's score (with default): " + davidsScoreOrDefault);
// 输出: David's score (with default): -1
// key "Alice" 存在，则返回其真实值
Integer alicesScoreOrDefault = studentScores.getOrDefault("Alice", -1);
System.out.println("Alice's score (with default): " + alicesScoreOrDefault);
// 输出: Alice's score (with default): 95

获取 Map 中的所有 Value

如果你需要一次性获取 Map 中所有的 value，可以使用 values() 方法，它会返回一个 Collection<V>，包含了 Map 中的所有 value。

import java.util.Collection;
import java.util.Map;
public class GetAllValuesExample {
    public static void main(String[] args) {
        Map<String, String> countryCapitals = new HashMap<>();
        countryCapitals.put("USA", "Washington, D.C.");
        countryCapitals.put("UK", "London");
        countryCapitals.put("France", "Paris");
        // 使用 values() 获取所有 value 的集合
        Collection<String> capitals = countryCapitals.values();
        System.out.println("All capitals: " + capitals);
        // 输出可能为 (HashMap 的迭代顺序不保证): All capitals: [Washington, D.C., London, Paris]
        // 你可以像操作普通集合一样操作这个 Collection
        for (String capital : capitals) {
            System.out.println("Capital: " + capital);
        }
    }
}

Java 8+ 中的新方法 (函数式风格)

Java 8 引入了许多新特性，使得处理 Map 变得更加灵活和高效。

getOrDefault(key, defaultValue)

如上所述,这是处理 key 不存在情况的绝佳选择。

forEach(BiConsumer<? super K, ? super V>)

如果你想遍历 Map 并对每个 key-value 对执行某些操作，可以使用 forEach，它比传统的 for-each 循环更简洁。

Map<String, Integer> scores = new HashMap<>();
scores.put("Alice", 95);
scores.put("Bob", 88);
// 使用 forEach 遍历并打印 key 和 value
scores.forEach((name, score) -> {
    System.out.println(name + " scored " + score);
});
// 输出:
// Alice scored 95
// Bob scored 88

computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction)

这是一个非常强大的方法,如果指定的 key 不存在（或者其 value 为 null），它会使用给定的函数来计算 value，然后将 key 和计算出的 value 存入 Map 中，最后返回 value。

场景： 延迟初始化，一个缓存，只有在首次访问某个 key 时才去创建对象。

import java.util.HashMap;
import java.util.Map;
public class ComputeIfAbsentExample {
    public static void main(String[] args) {
        Map<String, StringBuilder> messageBuilders = new HashMap<>();
        // 尝试获取 "user1" 的 StringBuilder
        // 因为 "user1" 不存在，所以会执行 lambda 表达式创建一个新的 StringBuilder
        StringBuilder builder1 = messageBuilders.computeIfAbsent("user1", k -> new StringBuilder());
        // 向 builder1 追加内容
        builder1.append("Hello, ");
        builder1.append("World!");
        // 再次尝试获取 "user1"，这次它会直接返回已存在的 StringBuilder
        StringBuilder builder2 = messageBuilders.get("user1");
        System.out.println("builder1 == builder2? " + (builder1 == builder2)); // true
        System.out.println("Message for user1: " + builder2.toString()); // 输出: Message for user1: Hello, World!
        // "user2" 不存在，但这次我们只创建，不追加内容
        StringBuilder builder3 = messageBuilders.computeIfAbsent("user2", k -> new StringBuilder("Initial: "));
        System.out.println("Message for user2: " + builder3.toString()); // 输出: Message for user2: Initial:
    }
}

总结与最佳实践

核心建议：

1. 永远不要直接对 map.get(key) 的结果进行解操作（如 .toString() 或 .intValue()）而不进行 null 检查，除非你 100% 确定该 key 存在。
2. 在 Java 8 及更高版本中，优先考虑 getOrDefault，它能写出更健壮、更易读的代码。
3. 如果只是想遍历所有 value，使用 values() 是最简单直接的方式，如果需要在遍历时同时修改 Map，则应使用 iterator 的 remove() 方法，或者使用 Java 8 的流式操作。