核心概念

在深入方法之前,必须理解 HashMap 的两个核心概念：

1. 键-值对：HashMap 存储的是 Entry 对象，每个 Entry 对象包含一个 key 和一个 value。key 必须是唯一的。
2. 哈希冲突：不同的 key 可能有相同的哈希值（hashCode() 的结果）。HashMap 通过“链地址法”或“红黑树”来解决冲突，在 Java 8 中，当链表长度超过 8 且数组长度超过 64 时，链表会转换为红黑树以提高查询效率。

构造方法

创建 HashMap 实例时，可以使用不同的构造方法。

示例：

// 默认构造
Map<String, Integer> map1 = new HashMap<>();
// 指定初始容量
Map<String, Integer> map2 = new HashMap<>(32);
// 从另一个Map构造
Map<String, Integer> originalMap = new HashMap<>();
originalMap.put("A", 1);
Map<String, Integer> map3 = new HashMap<>(originalMap);

基本操作方法

这些是 HashMap 最常用、最核心的方法。

示例：

HashMap<String, Integer> scores = new HashMap<>();
// put
scores.put("Alice", 95);
scores.put("Bob", 88);
scores.put("Alice", 99); // 更新 Alice 的分数
System.out.println("After put: " + scores); // {Bob=88, Alice=99}
// get
Integer aliceScore = scores.get("Alice");
System.out.println("Alice's score: " + aliceScore); // 99
// containsKey
System.out.println("Contains 'Bob'? " + scores.containsKey("Bob")); // true
System.out.println("Contains 'Charlie'? " + scores.containsKey("Charlie")); // false
// remove
Integer removedScore = scores.remove("Bob");
System.out.println("Removed Bob's score: " + removedScore); // 88
System.out.println("After remove: " + scores); // {Alice=99}
// size, isEmpty
System.out.println("Size: " + scores.size()); // 1
System.out.println("Is empty? " + scores.isEmpty()); // false

批量操作方法

这些方法用于一次性操作整个映射。

示例：

HashMap<String, Integer> map1 = new HashMap<>();
map1.put("A", 1);
map1.put("B", 2);
HashMap<String, Integer> map2 = new HashMap<>();
map2.put("C", 3);
map2.put("A", 4); // map1 中也有的 key
// putAll: 将 map2 的内容合并到 map1，key 冲突，map1 的值会被 map2 的值覆盖。
map1.putAll(map2);
System.out.println("After putAll: " + map1); // {A=4, B=2, C=3}
// clear
map1.clear();
System.out.println("After clear: " + map1); // {}
System.out.println("Is empty? " + map1.isEmpty()); // true

视图操作方法

这些方法返回 HashMap 内部数据的“视图”，对视图的修改会直接反映到原始的 HashMap 中，它们是遍历和操作 HashMap 的强大工具。

示例：

HashMap<String, Integer> scores = new HashMap<>();
scores.put("Alice", 95);
scores.put("Bob", 88);
scores.put("Charlie", 76);
// 1. keySet() - 遍历 key
System.out.println("--- Traversing Keys ---");
for (String name : scores.keySet()) {
    System.out.println("Name: " + name);
}
// 2. values() - 遍历 value
System.out.println("\n--- Traversing Values ---");
for (Integer score : scores.values()) {
    System.out.println("Score: " + score);
}
// 3. entrySet() - 遍历 key-value 对 (推荐方式)
System.out.println("\n--- Traversing Entries ---");
for (Map.Entry<String, Integer> entry : scores.entrySet()) {
    System.out.println("Name: " + entry.getKey() + ", Score: " + entry.getValue());
}
// 通过视图修改原 Map
Set<String> keys = scores.keySet();
keys.remove("Bob"); // 直接通过视图的 remove 方法修改原 Map
System.out.println("\nAfter removing 'Bob' via keySet view: " + scores); // {Charlie=76, Alice=95}

其他实用方法

Java 8+ 新增方法

Java 8 为 HashMap 及其父接口 Map 引入了许多非常有用的方法，使其功能更强大。

示例 (Java 8+):

HashMap<String, Integer> map = new HashMap<>();
// getOrDefault
System.out.println("getOrDefault 'David': " + map.getOrDefault("David", 0)); // 0
// putIfAbsent
map.putIfAbsent("Alice", 95);
map.putIfAbsent("Alice", 100); // 不会执行，因为 Alice 已存在
System.out.println("After putIfAbsent: " + map); // {Alice=95}
// replace
map.replace("Alice", 98);
System.out.println("After replace: " + map); // {Alice=98}
// replace with old value check
map.replace("Alice", 98, 99); // 会执行，因为旧值是98
map.replace("Alice", 100, 99); // 不会执行，因为旧值不是100
System.out.println("After conditional replace: " + map); // {Alice=99}
// remove with old value check
map.remove("Alice", 99); // 会执行，成功移除
map.remove("Alice", 95); // 不会执行，因为 Alice 已不存在
System.out.println("After conditional remove: " + map); // {}
// computeIfAbsent
map.computeIfAbsent("Bob", k -> 0); // Bob 不存在，则计算并设置其值为 0
map.computeIfAbsent("Bob", k -> 100); // Bob 已存在，此操作不执行
System.out.println("After computeIfAbsent: " + map); // {Bob=0}
// forEach
map.forEach((k, v) -> System.out.println("Key: " + k + ", Value: " + v));
// 输出:
// Key: Bob, Value: 0
// merge
map.merge("Bob", 5, Integer::sum); // Bob 存在，将 0 + 5 = 5 作为新值
map.merge("Charlie", 10, Integer::sum); // Charlie 不存在，直接设置为 10
System.out.println("After merge: " + map); // {Bob=5, Charlie=10}

遍历 HashMap 的几种方式

遍历是 HashMap 的核心操作，主要有以下四种方式：

使用 entrySet() 和 for-each 循环 (推荐)

这是最常用、最高效的方式，因为它通过迭代器直接访问 Map.Entry 对象，避免了多次调用 get() 方法。

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

使用 keySet() 和 for-each 循环

这种方式先遍历 key，然后在循环体中通过 key 获取 value，如果只需要 key，这种方式很方便。

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

使用 Iterator

entrySet(), keySet(), values() 都返回一个集合，可以使用迭代器进行遍历。

Iterator<Map.Entry<String, Integer>> iterator = map.entrySet().iterator();
while (iterator.hasNext()) {
    Map.Entry<String, Integer> entry = iterator.next();
    // 可以在遍历时安全地删除元素
    if (entry.getValue() < 50) {
        iterator.remove();
    }
}

使用 Java 8 的 forEach 和 Lambda 表达式

代码简洁,函数式风格。

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

掌握这些方法,特别是 entrySet() 遍历和 Java 8 引入的新方法，将极大地提高你使用 HashMap 的效率和代码质量。