Java HashMap 详解:排序、遍历与修改值

HashMap 是 Java 集合框架 (java.util) 中最常用且功能强大的数据结构之一。它基于哈希表实现,提供了 键(Key) - 值(Value) 对的存储,并通过键实现高效的插入、删除和查找操作(平均时间复杂度接近 O(1))。

然而,HashMap 的核心设计强调速度而非顺序。这使得开发者经常需要在以下三个核心操作上花费功夫:

  1. 排序 (Sorting): 如何按照特定的规则(如键的自然顺序或值的数值大小)获取一个有序的键值对视图?
  2. 遍历 (Iteration/Looping): 如何安全有效地访问映射中的每一个键值对?
  3. 修改值 (Modifying Values): 如何在遍历过程中安全地更新映射条目的值?

本文将深入探讨 HashMap 在这些方面的详细技术实现、常见模式、最佳实践以及需要注意的陷阱,并通过实用的 Java 代码示例进行说明。

目录#

  1. 引言
  2. HashMap基础知识回顾
  3. HashMap的遍历(迭代循环)
    1. 使用 entrySet() 和增强的 for 循环 (推荐)
    2. 使用 keySet() 和增强的 for 循环
    3. 使用 Iterator
    4. 使用 values() 遍历值
    5. Java 8+:使用 forEach() 和 Lambda 表达式 (推荐)
    6. 遍历时的并发修改
  4. HashMap的排序
    1. 为何HashMap本身无序
    2. 按值排序](#按值排序)
      1. 使用Stream API
      2. 创建自定义 Entry 列表
    3. 按键排序](#按键排序)
      1. 使用 TreeMap (创建新有序映射)
      2. 使用Stream API按Key排序
  5. 在遍历过程中修改HashMap的值
    1. 使用 entrySet()
    2. 使用 Iterator
    3. 使用 replaceAll() (Java 8+)
    4. 使用 compute(), computeIfPresent(), computeIfAbsent() (Java 8+ 推荐)
    5. 注意事项与警告
  6. 总结
  7. 参考

2. HashMap基础知识回顾#

  • 存储结构: HashMap 底层是一个 Node<K,V>[] table 数组(桶)。每个 Node 存储一个键值对。
  • 散列函数: 使用键的 hashCode() 方法计算哈希值。通过特定的算法(如取模运算)将哈希值映射到数组的索引(桶位置)。
  • 哈希冲突: 不同的键可能计算出相同的桶索引。HashMap 使用链表或红黑树(在 Java 8+ 中,当链表长度超过阈值时转化为红黑树)来解决冲突。冲突的元素存储在同一个桶中。
  • 无序性: 元素被存储的桶位置由其哈希值决定,迭代器遍历时访问元素的顺序既不是插入顺序,也不是键的自然顺序。这个顺序依赖于哈希函数的具体实现、当前容量、以及冲突情况,并且在容量发生变化时可能会完全不同。HashMap 明确不保证迭代顺序。
  • 常用方法:
    • put(K key, V value): 添加键值对(若键已存在则替换旧值)。
    • get(Object key): 根据键获取值。
    • remove(Object key): 根据键删除键值对。
    • keySet(): 返回所有键的 Set 视图。
    • values(): 返回所有值的 Collection 视图。
    • entrySet(): 返回所有键值对(Map.Entry<K,V> 对象)的 Set 视图。这是遍历和修改的核心入口点。
    • size(): 获取键值对数量。
    • isEmpty(): 判断是否为空。
    • containsKey(Object key): 判断是否包含指定键。
    • containsValue(Object value): 判断是否包含指定值(性能一般 O(n))。

3. HashMap的遍历(迭代循环)#

有多种方法可以遍历 HashMap 中的所有键值对。

3.1 使用 entrySet() 和增强的 for 循环 (推荐)#

这是最常用且高效(特别是当需要同时访问键和值时)的方法。

HashMap<String, Integer> salaryMap = new HashMap<>();
salaryMap.put("Alice", 85000);
salaryMap.put("Bob", 75000);
salaryMap.put("Charlie", 92000);
 
// 遍历每个键值对
for (Map.Entry<String, Integer> entry : salaryMap.entrySet()) {
    String employee = entry.getKey(); // 获取键
    Integer salary = entry.getValue(); // 获取值
    System.out.println(employee + ": $" + salary);
}
  • 原理: entrySet() 返回一个包含所有 Map.Entry 对象的 Set。每个 Map.Entry 代表一个键值对。
  • 优点:
    • 在单次迭代中同时获取键和值,避免了通过键再查找值的开销(get(key) 方法调用)。
    • 语法简洁(增强的 for 循环)。
  • 最佳实践: 当遍历需要访问或修改键或值时,优先使用此方法。

3.2 使用 keySet() 和增强的 for 循环#

如果需要遍历并处理键,或者根据键获取值。

HashMap<String, Integer> salaryMap = ...; // 同上
 
// 遍历每个键
for (String employee : salaryMap.keySet()) {
    // 通过键获取对应的值(额外的查找操作)
    Integer salary = salaryMap.get(employee);
    System.out.println(employee + ": $" + salary);
}
  • 原理: keySet() 返回一个包含所有键的 Set。遍历键集合时,再通过 get(key) 方法获取对应的值。
  • 缺点:
    • 效率较低:get(key) 操作本质上是对 HashMap 的再一次查找(平均 O(1),但仍然比 entrySet() 直接访问值多了一次操作)。
    • 如果值在遍历过程中被修改或键值映射关系不存在(get 返回 null),可能需要额外处理。
  • 适用场景: 当遍历仅需处理键时,或者由于特定原因只需要处理键时可以使用。但若需要键值都处理,entrySet() 更优。

3.3 使用 Iterator#

提供了在遍历过程中安全删除元素的途径(非并发修改场景)。

HashMap<String, Integer> salaryMap = ...; // 同上
 
Iterator<Map.Entry<String, Integer>> iterator = salaryMap.entrySet().iterator();
while (iterator.hasNext()) {
    Map.Entry<String, Integer> entry = iterator.next();
    String employee = entry.getKey();
    Integer salary = entry.getValue();
    System.out.println(employee + ": $" + salary);
 
    // 使用迭代器的 remove 方法安全删除当前元素
    if (employee.equals("Bob")) {
        iterator.remove(); // 安全删除!
    }
}
  • 原理: 显式地通过 entrySet().iterator() 获取 Iterator,然后使用 hasNext() 和 next() 方法遍历。
  • 优点: 唯一允许在遍历过程中通过调用 Iterator 自身的 remove() 方法来安全删除当前元素的传统方式(非并发修改)。
  • 缺点: 语法相对冗长。
  • 重要: 使用 Iterator 时,只能通过它自己的 remove() 方法删除元素。尝试通过 HashMap 的原生方法(如 remove(key))删除元素会导致 ConcurrentModificationException(下一节解释)。

3.4 使用 values() 遍历值#

如果只需要处理值,不关心键。

HashMap<String, Integer> salaryMap = ...; // 同上
 
for (Integer salary : salaryMap.values()) {
    System.out.println("Salary: $" + salary);
}
  • 原理: values() 返回一个包含所有值的 Collection。直接遍历这个集合。
  • 适用场景: 仅需访问或修改值时使用。失去了键的上下文信息。

3.5 Java 8+:使用 forEach() 和 Lambda 表达式 (推荐)#

简洁、现代的遍历方式。

HashMap<String, Integer> salaryMap = ...; // 同上
 
// 使用 Lambda 表达式遍历 entrySet
salaryMap.forEach((employee, salary) -> {
    System.out.println(employee + ": $" + salary);
    // 可以在 Lambda 内部处理键值
});
 
// 如果需要修改值,通常不建议在 forEach Lambda 中直接设置值(参考第5节)
// salaryMap.forEach((k, v) -> v = v + 1000); // 这样修改的是Lambda参数v,不会改变Map中的值!
  • 原理: Map 接口在 Java 8 引入了 forEach(BiConsumer<? super K, ? super V> action) 方法。该方法接受一个 BiConsumer 函数式接口(接受键和值两个参数)。Lambda 表达式或方法引用可以简洁地定义这个行为。
  • 优点:
    • 语法极简,可读性强。
    • 内部通常利用 entrySet 的迭代实现,效率与 entrySet() 增强 for 循环相当。
  • 缺点:
    • 在 Lambda 内部直接使用 = 赋值给 v 无法修改原始 Map 中的值(Java 中参数是按值传递的)。安全的修改需要借助 Iterator、replaceAll 或 compute 方法(参见第 5 节)。
    • 同样面临并发修改问题(下一节)。

3.6 遍历时的并发修改#

问题核心: HashMap 不是线程安全的集合。其迭代器被设计为“fail-fast”,即快速失败。

  • ConcurrentModificationException (CME): 当使用迭代器、增强 for 循环(底层也是迭代器)或 Java 8 forEach 遍历一个 HashMap 时,如果在遍历过程中(不是在当前迭代器的 remove() 方法内)结构性修改了 Map(即添加、删除条目,或者如果覆盖 put 一个已存在键的值,在大多数实现中不算结构性修改,但直接修改 Map.Entry 对象持有的值不算结构性修改),迭代器会立即抛出 ConcurrentModificationException。

  • 何时发生:

    • 使用 iterator 或增强 for 循环遍历时,在循环体内部调用 HashMap 的 put(), remove() 或 clear() 等方法修改 Map。
    • 使用 iterator 的 next() 或 hasNext() 方法时检测到 Map 在迭代开始后被修改。
    • 使用 Java 8 forEach 遍历时,在 BiConsumer 内部修改 Map(例如调用 put 或 remove)。
  • 安全修改值:

    • 如果仅修改 Map.Entry 的 value 部分(例如通过 entry.setValue(newValue)),并且这种修改不是通过添加/删除元素完成的,那么通常不会触发 ConcurrentModificationException。Map.Entry.setValue() 会修改内部的映射关系。然而,这依赖于具体 Map 的实现。
    • 需要删除元素或在遍历中添加元素?必须使用 Iterator 的 remove() 方法(或 Java 8 的 removeIf),或者在遍历之外通过同步机制确保安全(对于并发访问,应使用 ConcurrentHashMap)。
  • 避免 CME 的策略:

    • 只读遍历: 如果在遍历过程中确定不修改 Map(包括添加、删除或调用 setValue),则无此问题。
    • 安全删除: 使用 Iterator 遍历时,通过 iterator.remove() 删除当前元素。
    • 收集后修改: 记录需要添加/删除/修改的键(例如添加到一个临时列表),在完成遍历后再统一处理这些更改。例如:
      List<String> toRemove = new ArrayList<>();
      for (Map.Entry<String, Integer> entry : salaryMap.entrySet()) {
          if (entry.getValue() < 80000) {
              toRemove.add(entry.getKey());
          }
      }
      toRemove.forEach(salaryMap::remove); // 或遍历 toRemove 用 remove(key)
    • Java 8 removeIf(Predicate<? super K>) (在键集上): 提供了一种优雅的删除方式。
      // 使用 keySet().removeIf(..) 安全删除满足条件的条目
      salaryMap.keySet().removeIf(employee -> employee.equals("Bob")); // 按键删除
      // 更通用的是在 entrySet 上,但标准JDK Map没有直接提供entrySet().removeIf。
      // 常用替代方案:
      salaryMap.entrySet().removeIf(entry -> entry.getValue() < 80000); // ★ 推荐!安全删除条件条目
    • ConcurrentHashMap: 如果确实需要在遍历时并发修改(添加、删除),或者在高并发环境下操作,必须使用 ConcurrentHashMap,它的迭代器是 “弱一致性” 的,不会抛出 CME。

最佳实践总结: 优先使用 entrySet() 或其衍生的 forEach() 进行只读遍历或仅修改值的操作。需要安全删除元素时,优先选择在 entrySet 上使用 removeIf(Predicate) 方法(如果条件基于键值对),或使用 Iterator 的 remove()。避免在遍历循环内部直接调用 HashMap 的修改方法。

4. HashMap的排序#

牢记:HashMap 本身设计上是无序的。不能直接对它进行排序。要实现“排序”效果,需要通过特定的方法创建一个有序的数据结构(如 List 或 TreeMap)来展示这些条目。

4.1 为何HashMap本身无序#

HashMap 使用哈希函数确定条目的存放位置(桶)。条目的存储和访问顺序完全取决于其键的哈希值、桶的索引计算、当前容量和冲突解决机制(链表/红黑树)。这个顺序是未定义的,并且在 Map 容量改变(Rehash)时会发生剧烈变化。

4.2 按值排序#

这是一个非常常见的需求(例如,显示员工薪水最高的前 N 个)。没有现成的排序 Map 可以按值排序(TreeMap 只能按键)。策略是创建一个临时的条目 (Map.Entry) 列表,然后按值对这个列表排序。

方法 1:使用 Stream API (Java 8+, 推荐)#

HashMap<String, Integer> salaryMap = ...; // {Alice=85000, Bob=75000, Charlie=92000}
 
// ★ 按值升序排序
List<Map.Entry<String, Integer>> sortedByValueAsc = salaryMap.entrySet()
        .stream()
        .sorted(Map.Entry.comparingByValue()) // 使用内置Comparator按值自然排序(升序)
        .collect(Collectors.toList());
System.out.println("升序: " + sortedByValueAsc); // [Bob=75000, Alice=85000, Charlie=92000]
 
// ★ 按值降序排序
List<Map.Entry<String, Integer>> sortedByValueDesc = salaryMap.entrySet()
        .stream()
        .sorted(Map.Entry.<String, Integer>comparingByValue().reversed()) // reversed()反转成降序
        .collect(Collectors.toList());
System.out.println("降序: " + sortedByValueDesc); // [Charlie=92000, Alice=85000, Bob=75000]
 
// ★ 自定义按值排序 (例如按姓名字母顺序作为第二关键字)
List<Map.Entry<String, Integer>> sortedByValueThenKey = salaryMap.entrySet()
        .stream()
        .sorted(Map.Entry.<String, Integer>comparingByValue() // 主排序:薪水升序
                .thenComparing(Map.Entry.comparingByKey())) // 次级排序:键(姓名)升序
        .collect(Collectors.toList());
System.out.println("薪水升->姓名升: " + sortedByValueThenKey);
  • 优点: 简洁、功能强大(支持链式调用排序、筛选、收集等),是现代 Java 的最佳实践。Map.Entry 提供的内置 Comparator (comparingByKey(), comparingByValue()) 以及 Comparator.reversed(), thenComparing() 让排序逻辑非常清晰。
  • 注意: 结果是 List<Map.Entry<K, V>>,不再是 Map。需要排序结果持久化?通常将其放入 LinkedHashMap(保留插入顺序):
    Map<String, Integer> sortedMapByValue = salaryMap.entrySet()
        .stream()
        .sorted(Map.Entry.<String, Integer>comparingByValue().reversed()) // 降序
        .collect(Collectors.toMap(
                Map.Entry::getKey, // Key mapper function
                Map.Entry::getValue, // Value mapper function
                (oldVal, newVal) -> oldVal, // Merge function (冲突处理,这里保留旧值)
                LinkedHashMap::new // Map supplier,使用LinkedHashMap保留排序顺序
        ));
    System.out.println(sortedMapByValue); // {Charlie=92000, Alice=85000, Bob=75000} (按值降序排列)
    使用 LinkedHashMap 保留了条目插入到 Map 时的顺序,而我们在 stream.collect 中插入条目的顺序就是排序后的顺序。这实现了类似“有序Map”的效果。

方法 2:创建自定义 Entry 列表 (Java 8 之前)#

HashMap<String, Integer> salaryMap = ...; // {Alice=85000, Bob=75000, Charlie=92000}
 
// 1. 创建一个包含所有条目的列表
List<Map.Entry<String, Integer>> entryList = new ArrayList<>(salaryMap.entrySet());
 
// 2. 使用Collections.sort()排序并传入自定义Comparator
Collections.sort(entryList, new Comparator<Map.Entry<String, Integer>>() {
    @Override
    public int compare(Map.Entry<String, Integer> e1, Map.Entry<String, Integer> e2) {
        return e1.getValue().compareTo(e2.getValue()); // 按值升序
        // 按值降序: return e2.getValue().compareTo(e1.getValue());
        // 组合排序示例(薪水降序->姓名升序):
        //   int cmp = e2.getValue().compareTo(e1.getValue());
        //   if (cmp != 0) return cmp;
        //   return e1.getKey().compareTo(e2.getKey());
    }
});
 
// 3. 遍历排序后的列表
for (Map.Entry<String, Integer> entry : entryList) {
    System.out.println(entry.getKey() + ": " + entry.getValue());
}
  • 优点: 兼容 Java 7 及更早版本。
  • 缺点: 代码相对冗长。手动编写 Comparator。

4.3 按键排序#

按键排序通常更容易,因为键通常实现了 Comparable 接口(如 String, Integer)。如果你需要一个持续按键排序的 Map,首选 TreeMap。如果只是临时得到一个排序视图,可以使用类似值排序的方法或 TreeMap。

方法 1:使用 TreeMap (创建新有序映射)#

HashMap<String, Integer> salaryMap = ...; // {Charlie=92000, Alice=85000, Bob=75000}
 
// ★ 创建一个按键自然顺序排序的新TreeMap (直接传入HashMap)
Map<String, Integer> sortedMapByKey = new TreeMap<>(salaryMap);
 
// ★ 遍历TreeMap会按键的自然顺序(对String是字母顺序)输出
for (Map.Entry<String, Integer> entry : sortedMapByKey.entrySet()) {
    System.out.println(entry.getKey() + ": " + entry.getValue());
} // 输出: Alice:85000, Bob:75000, Charlie:92000
 
// ★ 提供自定义Comparator进行排序(例如按键长度排序)
Map<String, Integer> sortedByKeyLength = new TreeMap<>((key1, key2) -> 
        Integer.compare(key1.length(), key2.length()));
sortedByKeyLength.putAll(salaryMap);
System.out.println(sortedByKeyLength); // {Bob=75000, Alice=85000, Charlie=92000} 假设输入顺序为Charlie,Alice,Bob
                                      // 实际按键长度升序排序: Bob(3), Alice(5), Charlie(7)
  • 优点:
    • TreeMap 实现了 SortedMap/NavigableMap 接口,天生有序。任何后续的遍历操作都基于排序顺序。
    • 支持高效的按键范围查询(headMap(), tailMap(), subMap())。
  • 缺点:
    • 插入和删除操作的平均时间复杂度是 O(log n),比 HashMap 的 O(1) 慢。
    • 创建新对象需要额外的内存开销(如果 salaryMap 很大)。
    • 是对原始 HashMap 的一个快照拷贝。后续对原 salaryMap 的更改不会反映在 TreeMap 中(除非再次拷贝)。

方法 2:使用 Stream API 按键排序#

类似按值排序。

HashMap<String, Integer> salaryMap = ...; // {Charlie=92000, Alice=85000, Bob=75000}
 
// ★ 按键升序的List<Entry>
List<Map.Entry<String, Integer>> sortedByKeyAscList = salaryMap.entrySet()
        .stream()
        .sorted(Map.Entry.comparingByKey())
        .collect(Collectors.toList());
 
// ★ 按键降序并放入LinkedHashMap
Map<String, Integer> sortedByKeyDescLinkedMap = salaryMap.entrySet()
        .stream()
        .sorted(Map.Entry.<String, Integer>comparingByKey().reversed())
        .collect(Collectors.toMap(
                Map.Entry::getKey,
                Map.Entry::getValue,
                (o, n) -> o,
                LinkedHashMap::new
        ));
  • 优点: 灵活性高,一次处理(排序、过滤、收集)。结果可以是列表也可以是保留顺序的 LinkedHashMap。
  • 缺点: LinkedHashMap 仅保留插入顺序,不提供 TreeMap 的导航功能。需要排序结果多次使用时,可能不如创建 TreeMap 高效。

排序策略选择建议:

  • 需要持续按键排序的 Map,并且支持范围查询? -> TreeMap。
  • 需要一次性按键排序展示? -> Stream API + LinkedHashMap 或 Stream API + List Collectors.toList()。
  • 需要按值排序展示? -> Stream API + List 或 Stream API + LinkedHashMap。TreeMap 不适用于按值排序。
  • 需要基于复杂条件排序? -> Stream API + 自定义 Comparator 链。

5. 在遍历过程中修改HashMap的值#

这是 HashMap 操作中的关键一点。如前所述,不能通过 keySet() 遍历获取到的值引用进行简单赋值修改(修改的是局部变量),也不推荐在 forEach lambda 中简单赋值给参数 v(同样修改的是局部参数)。

安全有效的修改值方法如下:

5.1 使用 entrySet()#

通过获得的 Map.Entry 对象调用其 setValue(V newValue) 方法。

HashMap<String, Integer> salaryMap = new HashMap<>();
salaryMap.put("Alice", 85000);
salaryMap.put("Bob", 75000);
salaryMap.put("Charlie", 92000);
 
// ★ 直接修改值 - 使用 entrySet()
for (Map.Entry<String, Integer> entry : salaryMap.entrySet()) {
    String name = entry.getKey();
    Integer currentSalary = entry.getValue();
    // 给Bob加薪 5000
    if (name.equals("Bob")) {
        int newSalary = currentSalary + 5000;
        entry.setValue(newSalary); // ★★★ 使用Entry的setValue方法直接修改映射值
    }
}
 
System.out.println(salaryMap.get("Bob")); // 输出: 80000
  • 原理: Map.Entry.setValue(newValue) 方法会更新这个条目在 HashMap 映射中的值部分。
  • 优点:
    • 在遍历(entrySet() for 循环)中直接修改。不需要额外的查找或创建新条目。
    • 不改变键,因此不会改变条目的存储桶位置(除非哈希冲突结构被改变,但值改变本身不影响哈希桶位置)。
  • 警告:
    • 如前所述,如果其他线程并发修改了 Map(导致结构性修改),在迭代过程中修改值可能触发 ConcurrentModificationException。对于并发访问,请使用 ConcurrentHashMap 并阅读其文档关于弱一致性迭代器的说明。
    • 修改发生在原始 HashMap 上。

5.2 使用 Iterator#

原理同 entrySet(),但通过 Iterator 获取的 Entry 进行修改。

Iterator<Map.Entry<String, Integer>> iterator = salaryMap.entrySet().iterator();
while (iterator.hasNext()) {
    Map.Entry<String, Integer> entry = iterator.next();
    if (entry.getKey().equals("Bob")) {
        entry.setValue(entry.getValue() + 5000); // 同样使用setValue修改
    }
}

行为与直接使用 entrySet() for 循环修改值相同。

5.3 使用 replaceAll() (Java 8+)#

对 Map 中每一个条目独立应用一个函数来生成新值替换旧值。

HashMap<String, Integer> salaryMap = ...; // {Alice=85000, Bob=75000, Charlie=92000}
 
// 给所有人加薪 5%
salaryMap.replaceAll((key, oldValue) -> (int) (oldValue * 1.05));
 
System.out.println(salaryMap);
// 输出可能类似(顺序不确定): {Alice=89250, Bob=78750, Charlie=96600}
  • 原理: Map.replaceAll(BiFunction<? super K, ? super V, ? extends V> function) 方法对 Map 中的每个条目调用 function 函数。函数的参数是键 key 和旧值 oldValue,返回值 newValue 会替换该条目原来的值。
  • 优点:
    • 语法非常简洁(Lambda 表达式或方法引用)。
    • 内部高效实现。
  • 缺点:
    • 新值的计算必须是无状态的,只依赖当前的键和旧值。
    • 是对 所有 条目的批量操作。如果需要条件修改,需要在 BiFunction 内实现条件逻辑:
      salaryMap.replaceAll((key, value) -> 
          key.startsWith("C") ? value * 1.10 : value); // 给C开头名字的人加薪10%
    • 修改发生在原始 HashMap 上。

5.4 使用 compute(), computeIfPresent(), computeIfAbsent() (Java 8+ 推荐)#

这些方法提供基于键的原子性值计算。

  • compute(K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction): 计算指定键的新值。传入的函数接受键 key 和旧值 oldValue(如果键不存在,oldValue 为 null),返回新值 newValue。
    • 如果 remappingFunction 返回 null,并且该键原先存在,则删除该条目。
    • 如果 remappingFunction 返回 non-null:
      • 如果键不存在,则添加 (key, newValue) 条目。
      • 如果键存在,则用 newValue 替换旧值。
HashMap<String, Integer> salaryMap = new HashMap<>();
salaryMap.put("Alice", 85000);
salaryMap.put("Bob", 75000);
 
// ★ 修改Bob的薪水 (增加5000)
salaryMap.compute("Bob", (key, oldSalary) -> oldSalary + 5000); // Bob存在
System.out.println(salaryMap.get("Bob")); // 80000
 
// ★ 尝试修改Charlie的薪水,但Charlie不存在。compute会添加
salaryMap.compute("Charlie", (key, oldSalary) -> 100000); // key "Charlie"不存在,oldSalary=null, 添加 (Charlie, 100000)
System.out.println(salaryMap.get("Charlie")); // 100000
 
// ★ 通过返回null删除Alice
salaryMap.compute("Alice", (key, oldSalary) -> null); // 删除Alice条目
System.out.println(salaryMap.containsKey("Alice")); // false
  • V computeIfPresent(K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction): 仅当键存在时(且映射的值非 null),才计算新值。如果函数返回 null,则删除该条目。如果键不存在或映射为 null,什么也不做并返回 null。
salaryMap.computeIfPresent("Bob", (k, v) -> v + 2000); // Bob存在, 值变成82000
salaryMap.computeIfPresent("Eve", (k, v) -> v + 2000); // Eve不存在,啥也不做,返回null
  • V computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction): 仅当键不存在或映射为 null 时,才使用 mappingFunction 计算新值并添加 (key, computedValue) 条目。如果键存在且值非 null,则返回现有值,不执行计算。
salaryMap.computeIfAbsent("David", k -> 90000); // David不存在,添加 (David, 90000)
salaryMap.computeIfAbsent("Bob", k -> 0); // Bob已存在,返回旧值82000,不会修改成0
  • 优点:
    • 原子性: 对于给定的键 key,这些方法的执行是原子性的(在同一 Map 上)。这在使用外部同步的 HashMap 时或在 ConcurrentHashMap 中是重要的优势(对于 HashMap,单线程中使用,主要是避免了显式检查 containsKey -> get/put/remove 之间的竞态条件)。
    • 表达力强: 在一个操作内完成“检查->计算->更新/添加/删除”。
    • 不需要遍历也能修改特定键的值(也可以用于遍历)。
  • 在遍历中使用示例:
    // ★★★ 安全做法:在遍历entrySet时,使用compute方法修改值 (键不变,安全操作)
    HashMap<String, Integer> salaryMap = new HashMap<>();
    salaryMap.put("Alice", 85000);
    salaryMap.put("Bob", 75000);
    salaryMap.put("Charlie", 92000);
     
    for (String key : salaryMap.keySet()) { // 遍历键集(注意:这里对keySet的遍历是安全的,因为值修改不影响Map的结构)
        salaryMap.compute(key, (k, v) -> v * 1.05); // 安全:修改值不改变键(所以不改变结构)
    }
    // ★ 更好:直接用replaceAll更简洁。但compute方式展示了其在遍历特定键时的可用性。
    这个遍历修改是安全的,因为 compute 修改的是与特定键关联的值,不涉及添加或删除条目(即没有结构性修改),因此不会抛出 ConcurrentModificationException。但如果在 compute 函数中根据某些逻辑返回 null(删除键)或者插入新键,就会触发结构性修改并导致遍历时抛出 CME!。

修改值总结:

5.5 注意事项与警告#

  1. 赋值无效: Integer salary = map.get("Bob"); salary = salary + 5000; (修改局部变量 salary) 或 map.forEach((k, v) -> v = v + 5000) (修改 Lambda 参数 v) 都无效。这些操作不会影响原始 Map 中的值。
  2. 结构性修改:
    • 修改一个条目的值(使用 entry.setValue() 或基于键的 compute/replace 方法)通常不算结构性修改(除非这个操作导致内部冲突解决结构变化,如树化/反树化,但通常只影响一个桶)。
    • 添加新条目、删除条目或修改条目的键 (这是不可能的,要改键必须删除旧key+添加新key) 绝对是结构性修改。
    • 在迭代器遍历(包括 for-each 和 Java 8 forEach)中发生结构性修改(删除/添加/compute返回 null)会触发 ConcurrentModificationException。删除元素必须使用迭代器的 remove 方法或 removeIf。添加元素或复杂条件删除通常需要在遍历外部处理。
  3. 线程安全: HashMap 不是线程安全的。在多线程环境中修改值(即使只是修改值)也可能导致数据损坏或不一致。如果需要并发访问修改,请使用 ConcurrentHashMap。在 ConcurrentHashMap 中使用 entrySet().iterator() 或 entrySet().forEach() 遍历时,setValue 方法不是线程安全的!应优先使用其提供的 replace(K key, V value), replaceAll, compute 等方法进行原子修改。ConcurrentHashMap 的迭代器本身是弱一致性的。
  4. 推荐方法:
    • 在单线程中,安全修改值(不删除):
      • 遍历中直接修改:entry.setValue(newValue) (使用 entrySet() for循环)。
      • 批量修改所有值:replaceAll(BiFunction)。
      • 按特定键修改:compute()/computeIfPresent()/replace(K, V)。
    • 安全删除元素:
      • 在遍历中:iterator.remove() (使用显式 Iterator) 或在 entrySet() 上使用 removeIf(Predicate) (★ 最简洁推荐)。
      • 非遍历:remove(key), compute(key, ..., returns null), keySet().remove(key), keySet().removeIf(predicate)。

6. 总结#

  • 遍历: 优先使用 entrySet().forEach((k, v) -> { ... }) (Java 8+) 或 for (Map.Entry<K, V> entry : map.entrySet()) { ... } 进行只读或仅修改值的遍历。需要安全删除使用 entrySet().removeIf(Predicate) 或 Iterator.remove()。
  • 排序: HashMap 本身无序。按值排序使用 entrySet().stream().sorted(Map.Entry.comparingByValue(...)).collect(...)(结果存入 List 或 LinkedHashMap)。按键排序首选创建 TreeMap(创建新 Map,保留排序特性)或使用 Stream API 放入 LinkedHashMap。
  • 修改值: 绝不试图通过改变对通过 get(key) 或 forEach lambda 参数获得的引用来修改值。安全修改方法是:
    • entry.setValue(newValue) (在基于 entrySet() 的遍历中)。
    • map.replaceAll(function) (批量修改)。
    • map.compute(key, remappingFunction), map.computeIfPresent(key, remappingFunction), map.replace(key, newValue) (针对特定键)。
    • 注意避免在遍历中进行结构性修改(添加/删除),否则会触发异常。删除使用特定的安全删除方法。

理解 HashMap 的无序本质以及操作带来的结构性修改影响,并结合合适的 Java 特性和集合类(如 Stream, LinkedHashMap, TreeMap, Iterator, compute/replaceAll),才能高效、安全地完成排序、遍历和修改值的需求。

7. 参考#

  1. Java Platform Standard Ed. 17 - HashMap (Official Documentation): https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/HashMap.html (包含所有方法、构造函数的详细说明)
  2. Java Platform Standard Ed. 17 - Map (Official Documentation): https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Map.html (Map 接口的核心定义,包含 entrySet, forEach, replaceAll, compute 等方法)
  3. Java Platform Standard Ed. 17 - Map.Entry (Official Documentation): https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Map.Entry.html (Map.Entry 接口的定义,包含 getKey, getValue, setValue)
  4. Java Platform Standard Ed. 17 - Iterator (Official Documentation): https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Iterator.html (迭代器接口,包含 hasNext, next, remove)
  5. Java Platform Standard Ed. 17 - Collections Framework Overview: https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/package-summary.html (了解 HashMap 在集合框架中的位置)
  6. Java Platform Standard Ed. 17 - Stream API (java.util.stream package): https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/stream/package-summary.html (排序操作的核心工具)
  7. Effective Java (3rd Edition) by Joshua Bloch:
    • Item 34: Use enums instead of int constants (讨论使用Map关联枚举与值)
    • Item 63: Beware the performance of string concatenation (在日志打印时注意性能影响,但不影响本文核心逻辑)
    • 关于集合使用、equals/hashCode 的通用建议适用于 Map 键。
  8. 并发编程网: https://www.concurrent-programming.com/ (包含 HashMap 和 ConcurrentHashMap 底层原理的高级解析 - 适合深入了解).