Java中Map接口用于存储键值对，常用实现类有HashMap、LinkedHashMap、TreeMap和ConcurrentHashMap，各自适用于不同场景。HashMap基于哈希表实现，查找、插入、删除平均时间复杂度为O(1)，不保证顺序，适合大多数无需排序的场景；LinkedHashMap通过双向链表维护插入顺序，适用于需顺序遍历或实现LRU缓存的场景；TreeMap基于红黑树，按键自然顺序或自定义比较器排序，适用于需要有序键的场景，操作时间复杂度为O(logN)；ConcurrentHashMap为线程安全设计，采用分段锁或CAS机制，适用于高并发环境。使用Map时需注意：自定义对象作键时必须重写equals()和hashCode()方法，避免因哈希不一致导致无法正确存取；迭代过程中直接修改Map会抛出ConcurrentModificationException，应使用Iterator的remove()方法或延迟修改；为提升性能，可预设HashMap初始容量以减少扩容开销。Java 8新增多种便捷方法：forEach()简化遍历；getOrDefault()提供默认值避免空指针；putIfAbsent()实现存在则不插入；computeIfAbsent()支持延迟计算初始化，常用于构建多值映射；computeIfPresent()和compute()用于条件更新或合并值；merge()可将新值与旧值按规则合并，适用于计数、
Java中Map接口是存储键值对（key-value pairs）的核心工具，它提供了一种高效、灵活的方式，通过唯一的键来快速查找对应的值。你可以把它想象成一本字典，每个词条（键）都对应着一个解释（值），而且每个词条都是独一无二的。
解决方案
在Java中使用Map存储键值对，通常我们会选择其具体的实现类，比如
HashMap、
LinkedHashMap或
TreeMap。最常见、也是性能表现最均衡的当属
HashMap。
要开始使用，你只需要声明一个Map对象，并指定键和值的类型。例如，如果你想存储学生的ID（整数）和他们的名字（字符串）：
import java.util.HashMap;
import java.util.Map;
public class MapExample {
public static void main(String[] args) {
// 声明并初始化一个HashMap
Map studentNames = new HashMap<>();
// 存储键值对：使用put()方法
studentNames.put(101, "张三");
studentNames.put(102, "李四");
studentNames.put(103, "王五");
studentNames.put(101, "张三丰"); // 键重复时，新的值会覆盖旧的值
System.out.println("Map中的所有学生: " + studentNames); // {101=张三丰, 102=李四, 103=王五}
// 获取值：使用get()方法，传入键
String nameOf102 = studentNames.get(102);
System.out.println("ID为102的学生是: " + nameOf102); // 李四
// 检查键是否存在：使用containsKey()
boolean has103 = studentNames.containsKey(103);
System.out.println("是否存在ID为103的学生? " + has103); // true
// 检查值是否存在：使用containsValue()
boolean hasWangWu = studentNames.containsValue("王五");
System.out.println("是否存在名为王五的学生? " + hasWangWu); // true
// 移除键值对：使用remove()方法
studentNames.remove(102);
System.out.println("移除ID为102的学生后: " + studentNames); // {101=张三丰, 103=王五}
// 获取Map的大小
int size = studentNames.size();
System.out.println("Map中当前学生数量: " + size); // 2
// 遍历Map：
// 1. 遍历键集
System.out.println("所有学生ID:");
for (Integer id : studentNames.keySet()) {
System.out.println(id);
}
// 2. 遍历值集
System.out.println("所有学生姓名:");
for (String name : studentNames.values()) {
System.out.println(name);
}
// 3. 遍历键值对集（推荐，效率更高）
System.out.println("所有学生信息:");
for (Map.Entry entry : studentNames.entrySet()) {
System.out.println("ID: " + entry.getKey() + ", 姓名: " + entry.getValue());
}
// 使用Java 8的forEach方法遍历
System.out.println("使用forEach遍历:");
studentNames.forEach((id, name) -> System.out.println("ID: " + id + ", 姓名: " + name));
}
} 这段代码基本上涵盖了Map接口最常用的操作。你会发现，它的API设计得非常直观，大部分方法名都能顾名思义。
立即学习“Java免费学习笔记（深入）”；
什么时候该选哪种Map实现？HashMap、LinkedHashMap还是TreeMap？
说实话，这真的是个老生常谈但又不得不提的问题。不同的场景对Map的性能、顺序要求都不一样，选错了可能导致性能瓶颈或者逻辑错误。
-
HashMap
：最常用，性能优先，不保证顺序。-
特点： 基于哈希表实现，查找、插入、删除的平均时间复杂度是O(1)，效率极高。它不保证元素的迭代顺序，也就是说，你插入的顺序和遍历出来的顺序可能完全不一样。允许一个
null
键和多个null
值。 -
适用场景： 绝大多数情况下，如果你不需要保持元素的插入顺序或对键进行排序，
HashMap
就是你的首选。比如，缓存数据、统计词频、快速查找对象等。在我个人经验里，90%以上的Map使用场景，HashMap
都能胜任。 -
小提示： 如果你的自定义对象作为键，一定要正确重写
equals()
和hashCode()
方法，否则HashMap
就“迷茫”了，可能会把不同的对象当作同一个键，或者找不到本该存在的键。
-
特点： 基于哈希表实现，查找、插入、删除的平均时间复杂度是O(1)，效率极高。它不保证元素的迭代顺序，也就是说，你插入的顺序和遍历出来的顺序可能完全不一样。允许一个
-
LinkedHashMap
：保持插入顺序，或者访问顺序。-
特点： 继承自
HashMap
，底层也是哈希表，但它额外维护了一个双向链表，记录了元素的插入顺序。所以，当你遍历LinkedHashMap
时，元素的顺序就是你插入时的顺序。它还可以配置为按访问顺序（LRU，最近最少使用）排序。 -
适用场景： 当你需要一个既有
HashMap
的快速查找能力，又需要保持元素插入顺序的Map时，LinkedHashMap
是理想选择。比如，实现一个简单的LRU缓存（通过构造函数设置accessOrder
为true
），或者需要按顺序处理配置项等。 -
我个人看法： 它的性能比
HashMap
略低，因为多维护了一个链表，但对于大多数应用来说，这种开销可以忽略不计。
-
特点： 继承自
-
TreeMap
：键值对按键排序。-
特点： 基于红黑树实现，可以保证Map中的键值对是按照键的自然顺序（如果键实现了
Comparable
接口）或者自定义比较器（Comparator
）的顺序进行排序的。它的查找、插入、删除时间复杂度是O(logN)。 -
适用场景： 当你需要一个自动排序的Map时，
TreeMap
是唯一选择。例如，存储按字母顺序排列的用户列表、按日期排序的事件、或者需要进行范围查询（如查找某个范围内的所有键）等。 -
需要注意： 键必须是可比较的。如果你自定义对象作为键，它要么实现
Comparable
接口，要么在创建TreeMap
时提供一个Comparator
。
-
特点： 基于红黑树实现，可以保证Map中的键值对是按照键的自然顺序（如果键实现了
-
ConcurrentHashMap
：并发安全，高性能。-
特点： 这是
java.util.concurrent
包下的一个成员，专为多线程环境设计。它在保证线程安全的同时，提供了比Collections.synchronizedMap()
更好的并发性能，因为它采用了分段锁或者CAS操作等更细粒度的同步机制。 -
适用场景： 在多线程环境下，多个线程需要同时读写同一个Map时，为了避免数据不一致和
ConcurrentModificationException
，必须使用ConcurrentHashMap
。比如，共享缓存、统计计数器等。
-
特点： 这是
选择哪个，真的取决于你的具体需求。没有银弹，只有最适合的。
Map操作中常见的“坑”与优化策略
在使用Map时，有些地方一不留神就可能踩坑，或者写出性能不佳的代码。我总结了几个常见的点，希望能帮你避开它们。
-
自定义对象作为键时，务必重写
equals()
和hashCode()
：- 这是个经典的“坑”。
HashMap
（以及其他基于哈希表的集合如HashSet
）依赖这两个方法来判断两个键是否相等以及计算存储位置。如果你自定义了一个类作为Map的键，但没有重写这两个方法，那么即使两个对象在逻辑上是“相等”的，HashMap
也可能把它们当作不同的键，导致你put
了进去却get
不出来，或者错误地覆盖了值。 -
例子：
class MyKey { int id; String name; public MyKey(int id, String name) { this.id = id; this.name = name; } // 没有重写equals和hashCode，后果很严重 // @Override public boolean equals(Object o) { ... } // @Override public int hashCode() { ... } } Map -
解决方案： 使用IDE（如IntelliJ IDEA或Eclipse）自动生成
equals()
和hashCode()
方法，或者手动实现，确保它们基于对象的“业务唯一性”属性。
- 这是个经典的“坑”。
-
迭代Map时修改Map会导致
ConcurrentModificationException
：- 如果你在遍历
HashMap
、ArrayList
等非并发集合时，同时尝试通过集合自身的方法（如map.remove()
或map.put()
）修改集合，Java的快速失败（fail-fast）机制就会抛出ConcurrentModificationException
。这主要是为了提醒开发者，集合的结构在迭代过程中被意外修改了，可能导致不确定的行为。 -
解决方案：
- 使用迭代器（
Iterator
）自身的remove()
方法来移除当前元素。 - 如果你需要添加或修改，可以先收集需要修改的键，然后等迭代结束后再统一修改。
- 在多线程环境下，直接使用
ConcurrentHashMap
，它能处理并发修改。
- 使用迭代器（
- 如果你在遍历
-
初始化
HashMap
的容量：HashMap
在内部有一个默认的初始容量（通常是16）和加载因子（0.75）。当Map中的元素数量达到容量 * 加载因子时，HashMap
会自动扩容（rehash），这个过程会重新计算所有元素的哈希值并重新分配到新的桶中，这会消耗一定的性能。-
优化策略： 如果你预先知道Map大概会存储多少元素，可以在创建
HashMap
时指定一个合适的初始容量，避免不必要的扩容。一个经验法则是，将初始容量设置为你预计存储元素数量的1 / 加载因子 + 1
，或者干脆直接设置为你预估数量的2倍左右的2的幂次方。// 假设预计存储100个元素 Map
- 我个人习惯： 如果元素数量不多，或者不确定，就用默认的。如果确定会存大量数据，或者在性能敏感的地方，我会考虑设置初始容量。
Map与Java 8及更高版本的新特性结合
Java 8及之后的版本为Map接口引入了许多实用的新方法，让Map的操作更加简洁和高效。这些特性在实际开发中非常方便，能写出更优雅的代码。
-
forEach(BiConsumer action)
：更简洁的遍历- 替代了传统的for-each循环遍历
entrySet()
，代码更紧凑。Map
wordCounts.forEach((word, count) -> System.out.println(word + ": " + count)); // 输出: // apple: 5 // banana: 3
- 替代了传统的for-each循环遍历
-
getOrDefault(Object key, V defaultValue)
：优雅地处理键不存在的情况- 当键不存在时，不再返回
null
，而是返回你指定的默认值，避免了额外的null
检查。String fruit = wordCounts.getOrDefault("orange", 0).toString(); // getOrDefault返回的是Integer，这里为了打印转String System.out.println("Orange count: " + fruit); // Orange count: 0
- 当键不存在时，不再返回
-
putIfAbsent(K key, V value)
：仅当键不存在时才插入- 如果指定的键已经关联了一个值，则不执行任何操作并返回现有值。如果键不存在，则插入新的键值对并返回
null
。这个方法是原子性的，在并发场景下尤其有用。wordCounts.putIfAbsent("apple", 10); // "apple"已存在，不更新，返回5 wordCounts.putIfAbsent("grape", 2); // "grape"不存在，插入，返回null System.out.println(wordCounts); // {apple=5, banana=3, grape=2}
- 如果指定的键已经关联了一个值，则不执行任何操作并返回现有值。如果键不存在，则插入新的键值对并返回
-
computeIfAbsent(K key, Function mappingFunction)
：按需计算并插入- 如果Map中不存在指定键的映射，则使用
mappingFunction
计算一个新值，并将其与键关联起来。这对于缓存或延迟初始化非常有用。Map
- 如果Map中不存在指定键的映射，则使用
-
computeIfPresent(K key, BiFunction remappingFunction)
：仅当键存在时才计算并更新- 如果指定键存在，则使用
remappingFunction
计算一个新值，并将其与键关联。如果函数返回null
，则移除该键。wordCounts.computeIfPresent("apple", (k, v) -> v + 1); // "apple"存在，值更新为6 wordCounts.computeIfPresent("lemon", (k, v) -> v + 1); // "lemon"不存在，不执行 System.out.println(wordCounts); // {apple=6, banana=3, grape=2}
- 如果指定键存在，则使用
-
compute(K key, BiFunction remappingFunction)
：更通用的计算和更新- 无论键是否存在，都使用
remappingFunction
计算新值。如果函数返回null
，则移除键。wordCounts.compute("banana", (k, v) -> v == null ? 1 : v * 2); // "banana"存在，值更新为6 wordCounts.compute("cherry", (k, v) -> v == null ? 1 : v * 2); // "cherry"不存在，插入1 System.out.println(wordCounts); // {apple=6, banana=6, grape=2, cherry=1}
- 无论键是否存在，都使用
-
merge(K key, V value, BiFunction remappingFunction)
：合并值- 如果Map中不存在指定键的映射，则将给定值与键关联。如果键已经存在，则使用
remappingFunction
将现有值和给定值合并，并将结果与键关联。Map
- 如果Map中不存在指定键的映射，则将给定值与键关联。如果键已经存在，则使用
这些新特性真的大大简化了Map的常见操作，让代码更具表达力。我个人特别喜欢
computeIfAbsent和
getOrDefault，它们在处理默认值和按需初始化方面简直是神器。
