在 Java 开发中,HashMap 可以说是使用频率非常高的集合类。
无论是保存用户信息、统计数据,还是进行数据缓存,我们经常都会使用到 HashMap。
例如:
arduino
Map<String, Integer> map = new HashMap<>();
map.put("Java", 1);
map.put("Python", 2);
map.put("Go", 3);
System.out.println(map.get("Java"));
代码非常简单,但是你有没有想过几个问题:
- HashMap 为什么查询速度比较快?
- HashMap 底层到底是怎么存储数据的?
- 为什么 HashMap 使用数组和链表?
- 为什么 JDK 1.8 又引入了红黑树?
- HashMap 的扩容机制是怎样的?
今天就结合 JDK 1.8 的源码,聊聊 HashMap 的底层实现。
一、HashMap 的底层数据结构
在 JDK 1.8 中,HashMap 底层主要使用:
数组 + 链表 + 红黑树
可以先看一下整体结构:
sql
HashMap
|
Node<K,V>[] table
|
+------------+------------+
| | |
Node Node null
| |
Node Node
| |
Node 红黑树结构
这里的数组就是 HashMap 的主体结构。
每个数组元素可以存储一个 Node 节点。
当多个 Key 计算出来的数组下标相同时,就会发生哈希冲突。
JDK 1.8 中,发生冲突时,通常会通过链表的方式连接这些节点。
当链表长度达到一定条件,并且数组容量满足要求时,链表就可能转换成红黑树。
那么,为什么要这样设计呢?
原因主要是为了提高数据查询和插入的效率。
数组可以通过下标快速定位,链表可以解决哈希冲突,而红黑树则可以优化冲突严重时的查询效率。
二、HashMap 的 put() 方法是如何工作的?
我们平时使用 HashMap,最常见的操作就是 put()。
例如:
arduino
Map<String, Integer> map = new HashMap<>();
map.put("Java", 100);
这行代码执行时,HashMap 内部大致会经历以下几个步骤:
- 根据 Key 计算 Hash 值。
- 根据 Hash 值计算数组下标。
- 判断数组对应位置是否为空。
- 如果为空,直接插入节点。
- 如果不为空,则判断是否存在相同的 Key。
- 如果存在相同 Key,则替换 Value。
- 如果不存在,则将新节点加入链表或红黑树。
- 根据条件判断是否需要扩容。
我们先看看 HashMap 中计算 Hash 值的核心代码:
java
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
这里有一个比较有意思的操作:
scss
h ^ (h >>> 16)
为什么要这样计算?
因为 Java 中 hashCode() 返回的是一个 int 类型的哈希值。
HashMap 将高 16 位与低 16 位进行异或运算,让高位信息也参与低位计算,从而帮助减少部分哈希冲突。
接下来,通过计算结果获取数组下标:
bash
(n - 1) & hash
这里的 n 就是数组长度。
例如,数组长度为 16,那么:
ini
index = (16 - 1) & hash;
为什么不用取模运算?
因为 HashMap 的数组长度始终保持为 2 的幂次方,使用位运算可以更高效地计算数组下标。
三、什么是 HashMap 的哈希冲突?
了解 put() 的过程之后,还需要理解一个重要概念:哈希冲突。
所谓哈希冲突,就是不同的 Key 经过哈希计算后,最终得到相同的数组下标。
例如:
rust
数组下标:
0
1 -> Java
2
3 -> Python -> Go -> PHP
4
5
假设 Java、Python、Go、PHP 经过计算后,都落在数组下标 3 的位置。
那么这些数据就需要通过链表连接起来。
这就是 HashMap 使用链表解决哈希冲突的基本原理。
需要注意,哈希冲突不代表 Key 一定相同。
例如:
ini
String key1 = "Aa";
String key2 = "BB";
System.out.println(key1.hashCode());
System.out.println(key2.hashCode());
这两个字符串的 hashCode() 都是 2112。
但它们显然不是同一个字符串。
因此,HashMap 判断 Key 是否相同时,不能只依赖 hashCode(),还需要进一步判断 equals()。
四、为什么 JDK 1.8 引入红黑树?
在 JDK 1.7 中,HashMap 主要使用数组和链表解决哈希冲突。
但是,如果大量 Key 都发生哈希冲突,那么链表就会越来越长。
当链表长度较长时,查询数据就需要逐个遍历节点,最坏情况下时间复杂度为 O(n)。
为了解决这个问题,JDK 1.8 引入了红黑树。
红黑树是一种自平衡二叉搜索树,可以通过旋转和变色维持树的平衡。
在正常情况下,红黑树的查询时间复杂度为 O(log n)。
HashMap 中有几个比较重要的常量:
arduino
static final int TREEIFY_THRESHOLD = 8;
static final int UNTREEIFY_THRESHOLD = 6;
static final int MIN_TREEIFY_CAPACITY = 64;
它们分别代表:
| 常量 | 默认值 | 作用 |
|---|---|---|
| TREEIFY_THRESHOLD | 8 | 链表达到树化判断阈值 |
| UNTREEIFY_THRESHOLD | 6 | 扩容拆分时判断是否退化为链表 |
| MIN_TREEIFY_CAPACITY | 64 | 允许链表树化的最小数组容量 |
这里有一个容易理解错的地方:
链表长度达到 8,并不意味着一定会转换成红黑树。
如果当前数组容量还没有达到 64,HashMap 会优先尝试扩容,而不是直接树化。
这样设计是为了减少不必要的红黑树转换。
五、HashMap 的扩容机制
HashMap 还有一个比较重要的机制:扩容。
在 JDK 1.8 中,HashMap 默认初始容量为 16,默认负载因子为 0.75。
arduino
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
static final float DEFAULT_LOAD_FACTOR = 0.75f;
那么什么时候会发生扩容?
假设:
- 初始容量:16
- 负载因子:0.75
那么扩容阈值就是:
ini
16 × 0.75 = 12
当 HashMap 中元素数量超过扩容阈值时,就会触发扩容。
扩容之后,数组容量通常变成原来的两倍:
扩容前:16
扩容后:32
为什么要扩容?
因为数组容量越小,多个 Key 落在相同数组下标的概率通常越高。
适当扩大数组容量,可以降低哈希冲突的概率。
不过,扩容也不是没有代价。
扩容时需要重新分配数组,并处理原有节点的位置,因此会产生一定的性能开销。
JDK 1.8 对扩容过程做了一些优化。
它不需要像传统方式那样对每个节点重新计算完整的哈希下标,而是可以根据原容量对应的那一位判断节点是否需要移动。
例如:
arduino
if ((e.hash & oldCap) == 0) {
// 节点留在原位置
} else {
// 节点移动到原位置 + oldCap
}
这里的 oldCap 就是扩容之前的数组容量。
这种方式可以减少扩容过程中不必要的计算。
六、HashMap 为什么不保证线程安全?
在使用 HashMap 时,还需要注意一个问题:
HashMap 是非线程安全的集合类。
如果多个线程同时修改同一个 HashMap,可能出现数据覆盖、数据丢失等问题。
例如:
ini
Map<String, Integer> map = new HashMap<>();
Thread t1 = new Thread(() -> {
map.put("A", 1);
});
Thread t2 = new Thread(() -> {
map.put("B", 2);
});
t1.start();
t2.start();
这段代码虽然看起来很简单,但如果多个线程同时执行修改操作,HashMap 并没有提供必要的同步保护。
那么,如果业务中确实需要在多线程环境下使用 Map,应该怎么办?
通常有两种选择。
1. 使用 Collections.synchronizedMap()
arduino
Map<String, Integer> map =
Collections.synchronizedMap(new HashMap<>());
这种方式可以通过同步机制保护 Map 的操作。
2. 使用 ConcurrentHashMap
arduino
Map<String, Integer> map = new ConcurrentHashMap<>();
map.put("Java", 100);
map.put("Python", 200);
ConcurrentHashMap 是 Java 并发包中提供的线程安全 Map 实现。
在高并发场景下,通常优先考虑 ConcurrentHashMap。
另外需要注意,即使使用线程安全的 Map,多个操作组合起来也不一定天然具有原子性,具体还需要根据业务使用相应的原子操作。
七、HashMap 常见面试问题
最后整理几个 HashMap 比较常见的问题。
1. HashMap 的默认初始容量是多少?
默认初始容量为 16。
2. HashMap 的默认负载因子是多少?
默认负载因子为 0.75。
3. HashMap 为什么数组长度必须是 2 的幂次方?
因为这样可以使用位运算快速计算数组下标,同时也有利于扩容时优化节点迁移过程。
4. HashMap 可以存储 null 吗?
可以。
HashMap 允许一个 null Key,也允许多个 Value 为 null。
5. HashMap 为什么查询速度比较快?
因为可以通过 Key 的哈希值快速定位数组下标,正常情况下查询效率较高。
6. JDK 1.8 中 HashMap 的数据结构是什么?
数组 + 链表 + 红黑树。
7. HashMap 是线程安全的吗?
不是。如果需要线程安全的 Map,可以考虑 ConcurrentHashMap。