一、整体架构与数据结构
Java HashMap 是实现了 Map 接口的常用集合类，以键值对（key-value）的形式存储数据，允许一个 null 键和多个 null 值，并且不保证元素的顺序。其底层数据结构在 JDK 1.8 及以后发生了重要变化，采用数组 + 链表 + 红黑树的组合结构。
- 数组：也被称为哈希桶（bucket array），是 HashMap 的基础结构，每个数组元素存储链表或红黑树的头节点。数组长度始终为 2 的幂次方，这样做是为了在计算元素存储位置时，能够通过位运算替代取模运算，从而提高效率。
- 链表：当多个元素的哈希值经过计算后，对应到数组的同一个索引位置时，就会产生哈希冲突，此时这些元素会以链表的形式存储在该索引位置。在 JDK 1.8 之前，HashMap 仅通过链表解决哈希冲突。
- 红黑树：在 JDK 1.8 中引入，当链表的长度达到阈值（默认为 8），并且数组长度大于等于 64 时，链表会转换为红黑树，以提高查找效率。当红黑树节点数量减少到一定程度（默认为 6）时，又会退化为链表 。
// 核心属性定义
transient Node<K,V>[] table; // 哈希桶数组
transient int size; // HashMap中存储的键值对数量
int threshold; // 扩容阈值，当size >= threshold时进行扩容
final float loadFactor; // 负载因子，默认值为0.75
static final int TREEIFY_THRESHOLD = 8; // 链表转红黑树的阈值
static final int UNTREEIFY_THRESHOLD = 6; // 红黑树转链表的阈值
static final int MIN_TREEIFY_CAPACITY = 64; // 最小树化容量二、哈希算法与元素定位
2.1 哈希函数
HashMap 通过哈希函数计算键（key）的哈希值，以此来确定元素在数组中的存储位置。其哈希函数的核心代码如下：
static final int hash(Object key) {
int h;
return (key == null)? 0 : (h = key.hashCode()) ^ (h >>> 16);
}- 若键为 null，哈希值直接返回 0。
- 若键不为 null，先获取键的原始哈希值key.hashCode()，然后将其高 16 位与低 16 位进行异或（^）操作。这样做的目的是为了让哈希值更均匀地分布在数组中，减少哈希冲突的发生。例如，当数组长度较小时，低 16 位对索引计算的影响较大，通过异或操作能将高 16 位的特征也融入计算，从而降低冲突概率。
2.2 数组索引计算
在获取到键的哈希值后，需要进一步计算其在数组中的索引位置，计算公式为：
index = (n - 1) & hash;其中，n为数组的长度，hash为键的哈希值。该公式利用了位与（&）运算，当n为 2 的幂次方时，n - 1的二进制形式是全 1，通过位与运算能将哈希值映射到0到n - 1的范围内，从而确定元素在数组中的存储位置。这种位运算比传统的取模运算（hash % n）效率更高，因为位运算在计算机底层执行速度更快。
三、核心方法实现原理
3.1 put 方法
put 方法用于向 HashMap 中插入键值对，其执行流程如下：
- 首先计算键的哈希值：通过hash(key)方法计算键的哈希值。
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}检查数组是否初始化：如果哈希桶数组table为 null 或长度为 0，则调用resize()方法进行初始化。
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;计算元素在数组中的索引位置：根据哈希值计算索引i，如果该位置的数组元素为 null，则直接创建新的节点并插入。
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);- 如果索引位置的元素不为 null，说明发生了哈希冲突，此时分情况处理：
- 若该位置是链表结构：遍历链表，查找是否存在相同的键。如果找到相同的键，则更新其对应的值；如果遍历到链表末尾仍未找到相同的键，则在链表尾部插入新节点。当链表长度达到阈值TREEIFY_THRESHOLD（默认为 8），且数组长度大于等于MIN_TREEIFY_CAPACITY（默认为 64）时，将链表转换为红黑树。
- 若该位置是红黑树结构：直接调用红黑树的插入方法插入新节点。
else {
Node<K,V> e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}插入成功后，更新size并检查是否需要扩容：如果size大于等于threshold，则调用resize()方法进行扩容。
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;3.2 get 方法
get 方法用于根据键获取对应的值，其执行流程如下：
- 计算键的哈希值：同样通过hash(key)方法计算。
- 根据哈希值计算索引位置，获取该位置的数组元素。
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null? null : e.value;
}- 如果该位置的元素为 null，说明键不存在，直接返回 null。
- 如果该位置的元素不为 null，分情况查找：
- 若为链表结构：遍历链表，通过equals方法比较键是否相同，找到则返回对应的值；遍历完链表未找到则返回 null。
- 若为红黑树结构：调用红黑树的查找方法查找节点，找到则返回对应的值；未找到则返回 null。
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
return first;
if ((e = first.next) != null) {
if (first instanceof TreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
do {
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}四、扩容机制
当 HashMap 中的元素数量size达到扩容阈值threshold（threshold = 数组容量 * 负载因子，负载因子loadFactor默认为 0.75）时，会触发扩容操作，将数组容量扩大为原来的 2 倍。扩容的核心方法是resize()，其主要步骤如下：
- 保存旧数组的引用和相关属性，如容量oldCap和阈值oldThr。
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null)? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;- 计算新的数组容量和阈值：
- 如果旧容量为 0 且旧阈值大于 0，则新容量设为旧阈值，新阈值为旧阈值的 1.5 倍。
- 如果旧容量大于 0，则新容量为旧容量的 2 倍，新阈值同样为旧阈值的 2 倍。
- 如果旧容量和旧阈值都为 0，则使用默认的初始容量（16）和阈值（12，16 * 0.75）。
if (oldCap > 0) {
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
else { // zero initial threshold signifies using defaults
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}如果新阈值为 0，则根据新容量和负载因子计算新阈值。
if (newThr == 0) {
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY?
(int)ft : Integer.MAX_VALUE);
}
threshold = newThr;创建新的数组，并将旧数组中的元素重新分配到新数组中：遍历旧数组，对于每个链表或红黑树，根据元素的哈希值和新数组的容量重新计算索引位置，并将元素插入到新数组中。在重新分配过程中，如果链表长度小于等于UNTREEIFY_THRESHOLD（默认为 6），且数组长度大于等于MIN_TREEIFY_CAPACITY，则将红黑树退化为链表。
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // preserve order
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
next = e.next;
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;理解 Java HashMap 的底层原理，对于优化代码性能、解决实际开发中的问题以及应对面试都具有重要意义。在使用 HashMap 时，开发者可以根据具体需求，合理设置初始容量和负载因子，以减少哈希冲突和扩容带来的性能损耗。
扫一扫
2255
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
