Java HashMap 详解:排序、遍历与修改值
HashMap 是 Java 集合框架 (java.util) 中最常用且功能强大的数据结构之一。它基于哈希表实现,提供了 键(Key) - 值(Value) 对的存储,并通过键实现高效的插入、删除和查找操作(平均时间复杂度接近 O(1))。
然而,HashMap 的核心设计强调速度而非顺序。这使得开发者经常需要在以下三个核心操作上花费功夫:
- 排序 (Sorting): 如何按照特定的规则(如键的自然顺序或值的数值大小)获取一个有序的键值对视图?
- 遍历 (Iteration/Looping): 如何安全有效地访问映射中的每一个键值对?
- 修改值 (Modifying Values): 如何在遍历过程中安全地更新映射条目的值?
本文将深入探讨 HashMap 在这些方面的详细技术实现、常见模式、最佳实践以及需要注意的陷阱,并通过实用的 Java 代码示例进行说明。
目录#
- 引言
- HashMap基础知识回顾
- HashMap的遍历(迭代循环)
- HashMap的排序
- 为何HashMap本身无序
- 按值排序](#按值排序)
- 使用Stream API
- 创建自定义
Entry列表
- 按键排序](#按键排序)
- 使用
TreeMap(创建新有序映射) - 使用Stream API按Key排序
- 使用
- 在遍历过程中修改HashMap的值
- 总结
- 参考
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 节)。 - 同样面临并发修改问题(下一节)。
- 在 Lambda 内部直接使用
3.6 遍历时的并发修改#
问题核心: HashMap 不是线程安全的集合。其迭代器被设计为“fail-fast”,即快速失败。
-
ConcurrentModificationException(CME): 当使用迭代器、增强 for 循环(底层也是迭代器)或 Java 8forEach遍历一个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。
- 只读遍历: 如果在遍历过程中确定不修改 Map(包括添加、删除或调用
最佳实践总结: 优先使用 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中(除非再次拷贝)。
- 插入和删除操作的平均时间复杂度是 O(log n),比
方法 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 + ListCollectors.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上。
- 如前所述,如果其他线程并发修改了 Map(导致结构性修改),在迭代过程中修改值可能触发
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")); // falseV 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不存在,啥也不做,返回nullV 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 注意事项与警告#
- 赋值无效:
Integer salary = map.get("Bob"); salary = salary + 5000;(修改局部变量salary) 或map.forEach((k, v) -> v = v + 5000)(修改 Lambda 参数v) 都无效。这些操作不会影响原始 Map 中的值。 - 结构性修改:
- 修改一个条目的值(使用
entry.setValue()或基于键的compute/replace方法)通常不算结构性修改(除非这个操作导致内部冲突解决结构变化,如树化/反树化,但通常只影响一个桶)。 - 添加新条目、删除条目或修改条目的键 (这是不可能的,要改键必须删除旧key+添加新key) 绝对是结构性修改。
- 在迭代器遍历(包括
for-each和 Java 8forEach)中发生结构性修改(删除/添加/compute返回null)会触发ConcurrentModificationException。删除元素必须使用迭代器的remove方法或removeIf。添加元素或复杂条件删除通常需要在遍历外部处理。
- 修改一个条目的值(使用
- 线程安全:
HashMap不是线程安全的。在多线程环境中修改值(即使只是修改值)也可能导致数据损坏或不一致。如果需要并发访问修改,请使用ConcurrentHashMap。在ConcurrentHashMap中使用entrySet().iterator()或entrySet().forEach()遍历时,setValue方法不是线程安全的!应优先使用其提供的replace(K key, V value),replaceAll,compute等方法进行原子修改。ConcurrentHashMap的迭代器本身是弱一致性的。 - 推荐方法:
- 在单线程中,安全修改值(不删除):
- 遍历中直接修改:
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)或forEachlambda 参数获得的引用来修改值。安全修改方法是: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. 参考#
- Java Platform Standard Ed. 17 - HashMap (Official Documentation): https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/HashMap.html (包含所有方法、构造函数的详细说明)
- 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等方法) - 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) - 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) - 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 在集合框架中的位置)
- 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 (排序操作的核心工具)
- 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 键。
- 并发编程网: https://www.concurrent-programming.com/ (包含
HashMap和ConcurrentHashMap底层原理的高级解析 - 适合深入了解).