Java HashMap 详解

最新推荐文章于 2026-03-15 23:21:41 发布

原创最新推荐文章于 2026-03-15 23:21:41 发布 · 2.1k 阅读

38 ·

CC 4.0 BY-SA版权

文章标签：

#java #HashMap

java 同时被 2 个专栏收录

210 篇文章

订阅专栏

数据结构

45 篇文章

订阅专栏

Java `HashMap` 详解

HashMap 是 Java 中非常常用的集合类之一，它实现了 Map 接口，用于存储键值对（key-value）。HashMap 使用哈希表作为底层数据结构来存储数据，因此能提供快速的插入、删除和查找操作。以下是对 HashMap 的详细介绍。

1. `HashMap` 基本概念

HashMap 是一个实现了 Map 接口的集合类，用于存储 键值对。每个键（key）都是唯一的，对应一个值（value）。它的主要特性如下：

无序：HashMap 中的元素是无序的，即键值对的存储顺序不固定。
允许 null 键和值：HashMap 允许 null 作为键和值。对于键为 null 的情况，HashMap 会将其放在第一个位置。
线程不安全：HashMap 本身不是线程安全的。如果多个线程并发地访问和修改 HashMap，则需要额外的同步控制。

2. 工作原理

2.1 底层数据结构

HashMap 底层由数组和链表（或 红黑树）组成：

数组：HashMap 维护一个数组，每个数组元素称为桶（bucket）。当插入键值对时，HashMap 会通过哈希算法将键映射到数组的索引位置。
哈希函数：HashMap 使用 key.hashCode() 计算哈希值，将键映射到数组中。如果两个键的哈希值相同（哈希冲突），HashMap 会采用链表法或者红黑树来存储多个键值对。
链表与红黑树：当哈希冲突发生时，HashMap 使用链表或红黑树来存储冲突的元素。Java 8 之后，当链表的长度超过 8 时，HashMap 会将链表转换成红黑树，从而提高查找效率。

2.2 哈希冲突解决

链表法：当多个键的哈希值相同，它们会被存储在同一个桶内，以链表的形式连接。
红黑树法：当冲突的元素数量过多时（默认超过 8 个元素），HashMap 会将冲突桶中的链表转换为红黑树，从而使查找操作的时间复杂度从 O(n) 降低为 O(log n)。

2.3 扩容

HashMap 会根据负载因子（默认 0.75）来决定何时进行扩容。扩容时，HashMap 会创建一个新的数组，大小通常是原来数组大小的两倍，然后重新计算每个元素的位置并将其放入新的数组中。扩容操作的时间复杂度是 O(n)，因为需要将所有元素重新散列并放入新的桶中。

3. 常用方法

HashMap 提供了丰富的方法来操作键值对，包括插入、查找、删除、遍历等操作。下面列举了常见的操作方法：

3.1 插入元素

HashMap<Integer, String> map = new HashMap<>();
map.put(1, "Apple");   // 插入键 1，值 "Apple"
map.put(2, "Banana");  // 插入键 2，值 "Banana"
map.put(3, null);      // 插入键 3，值为 null
map.put(null, "Orange"); // 插入键为 null，值 "Orange"

put(K key, V value)：将一个键值对插入 HashMap。如果键已存在，则更新该键的值。

3.2 获取元素

String value = map.get(1);   // 返回 "Apple"
String value2 = map.get(4);  // 返回 null

get(Object key)：通过键获取对应的值。如果键不存在，则返回 null。

3.3 删除元素

map.remove(2);  // 删除键为 2 的元素

remove(Object key)：删除指定键的元素，并返回对应的值。如果键不存在，返回 null。

3.4 检查键或值是否存在

boolean containsKey = map.containsKey(1);  // 判断键 1 是否存在
boolean containsValue = map.containsValue("Banana");  // 判断值 "Banana" 是否存在

containsKey(Object key)：检查 HashMap 是否包含指定的键。
containsValue(Object value)：检查 HashMap 是否包含指定的值。

3.5 遍历

// 使用 entrySet() 遍历键值对
for (Map.Entry<Integer, String> entry : map.entrySet()) {
    System.out.println("Key: " + entry.getKey() + ", Value: " + entry.getValue());
}

// 使用 keySet() 遍历键
for (Integer key : map.keySet()) {
    System.out.println("Key: " + key);
}

// 使用 values() 遍历值
for (String value : map.values()) {
    System.out.println("Value: " + value);
}

entrySet()：返回 Map 中所有的键值对。
keySet()：返回 Map 中所有的键。
values()：返回 Map 中所有的值。

3.6 替换元素

map.replace(1, "Green Apple");  // 替换键为 1 的值为 "Green Apple"

replace(K key, V value)：替换指定键的值，如果键存在。

3.7 获取大小

int size = map.size();  // 获取 HashMap 的大小

size()：返回 HashMap 中键值对的数量。

4. 性能分析

时间复杂度：
- 插入：O(1)（在理想情况下，没有冲突时）。
- 查找：O(1)（在理想情况下，查找时间是常数时间）。
- 删除：O(1)（在理想情况下，删除操作是常数时间）。
- 哈希冲突：当发生哈希冲突时，时间复杂度会增加，但在大多数情况下，它仍然保持在 O(1) 或 O(log n)（通过红黑树）。
扩容操作：当 HashMap 中的元素数量超过容量的 75% 时，HashMap 会进行扩容，扩容时需要重新计算每个元素的位置，因此扩容的时间复杂度为 O(n)，这意味着扩容是一个较昂贵的操作，但在一般情况下，扩容的操作会少发生。
红黑树转换：如果桶中的元素数量超过 8 个，HashMap 会将链表转换成红黑树，从而将查找复杂度从 O(n) 优化为 O(log n)。

5. 内存和负载因子

5.1 负载因子（Load Factor）

HashMap 的负载因子决定了哈希表何时需要扩容。默认的负载因子为 0.75，意味着当 HashMap 的大小超过当前容量的 75% 时，它会进行扩容。负载因子过大或过小都会影响 HashMap 的性能：

负载因子大：减少了扩容的频率，但可能导致哈希冲突较多，影响查询性能。
负载因子小：扩容频率高，但哈希冲突较少，查询效率较高。

5.2 初始容量（Initial Capacity）

HashMap 的初始容量默认为 16，表示哈希表初始时有 16 个桶。初始容量越大，扩容的次数越少，但会消耗更多的内存。如果预计 HashMap 会存储大量数据，建议在创建时指定一个合理的初始容量来减少扩容的开销。

例如，如果预计需要存储 1000 个元素，可以这样初始化 HashMap：

HashMap<Integer, String> map = new HashMap<>(1000);

6. 线程安全性

HashMap 不是线程安全的。如果多个线程同时访问并修改 HashMap，可能会导致数据不一致和并发问题。为了确保线程安全，可以使用以下方法：

6.1 使用 `Collections.synchronizedMap()`

Collections.synchronizedMap() 可以将 HashMap 包装成一个线程安全的 Map，它会同步每个操作。这样可以避免并发问题，但它会降低性能，因为每次操作都会加锁。

Map<Integer, String> synchronizedMap = Collections.synchronizedMap(map);

6.2 使用 `ConcurrentHashMap`

对于高并发环境，HashMap 提供的线程安全机制不足以满足要求。为了更好的并发性能，Java 提供了 ConcurrentHashMap 类，它是线程安全的，并且提供了比 Collections.synchronizedMap() 更高效的并发控制。

ConcurrentHashMap 支持高效的并发读取和更新，它采用了分段锁（Segment Locking）的技术，将整个哈希表分成多个段，每个段可以独立加锁，这样可以大大减少锁竞争，提高并发性能。

ConcurrentHashMap 提供了常见的线程安全操作，如 putIfAbsent()、replace()、compute() 等，可以在并发操作时保证数据的安全性。

示例代码：

ConcurrentHashMap<Integer, String> concurrentMap = new ConcurrentHashMap<>();
concurrentMap.put(1, "Apple");
concurrentMap.put(2, "Banana");

// 原子操作
concurrentMap.putIfAbsent(3, "Orange");  // 如果键 3 不存在，才插入 "Orange"

7. `HashMap` 与 `TreeMap` 的比较

虽然 HashMap 是最常用的实现之一，但它和 TreeMap 有一些重要的区别：

排序：
- HashMap：不保证元素的顺序。
- TreeMap：根据键的自然顺序或提供的 Comparator 对键进行排序。
性能：
- HashMap：基于哈希表，查询、插入、删除的平均时间复杂度是 O(1)，但是在哈希冲突较多时，性能会下降。
- TreeMap：基于红黑树，查询、插入、删除的时间复杂度是 O(log n)，对于有序的数据，可以提供更好的性能。
使用场景：
- HashMap：适用于不需要保持键值对顺序的场景，查询和插入性能更高。
- TreeMap：适用于需要对键进行排序的场景，例如按顺序遍历键值对。

8. `HashMap` 的扩展与优化

8.1 选择合适的初始容量和负载因子

选择合适的初始容量可以减少扩容的次数，尤其在知道大致元素个数的情况下，指定一个合理的初始容量是一个性能优化点。
负载因子决定了哈希表的满载程度。默认的负载因子是 0.75，它在空间和时间的平衡方面表现较好。如果存储的数据量较少或者冲突较少，可以适当减小负载因子；如果数据量较大，可以适当增大负载因子来减少扩容次数。

8.2 避免过度哈希冲突

如果设计的 hashCode() 方法不好，可能会导致大量哈希冲突，进而影响性能。良好的 hashCode() 方法应该确保键的分布均匀，减少冲突。如果出现大量冲突，HashMap 的性能会受到影响，因为链表的查询性能是 O(n)。

8.3 使用合适的键

在使用 HashMap 时，选择合适的键非常重要。HashMap 依赖键的 hashCode() 和 equals() 方法来定位和比较键。因此，键的 hashCode() 必须是稳定的，不要在运行时修改键对象，否则可能导致不可预测的行为和性能问题。

9. 总结

HashMap 是 Java 中用于存储键值对的集合类，具有快速的查找、插入和删除操作，底层基于哈希表实现。其主要特点是：

无序性：HashMap 不保证元素的顺序。
允许 null：HashMap 允许 null 键和 null 值。
线程不安全：默认情况下，HashMap 是线程不安全的，需要额外的同步机制或使用线程安全的 ConcurrentHashMap 来确保并发安全。
性能：通过合适的哈希算法，HashMap 在查询和插入时通常具有 O(1) 的时间复杂度。但在哈希冲突较多时，性能可能下降。