版权声明：本文章原创于 RamboPan ，未经允许，请勿转载。
简谈 HashMap 扩容过程
- 第一次 2018年12月02日
- 第一次 2019年03月09日
- 调整代码块
- 变量、类名、方法 标记统一
无意看到了 HashMap 的扩容机制，想了挺久，才逐渐明白，感觉很精髓。
简单分享下自己理解的扩容过程。源码版本为 Android 28 JDK 1.8。
先简单说说 HashMap 结构，大家都知道它的内部存储结构是由一个数组进行散列存储。
如果把 n 个对象放入 n + 1 个格子里，就算 n 个平均散列了，第 n + 1 个肯定会放入 n 个格子中一个。
那既然会出现冲突的情况，肯定需要解决。 HashMap 采用的是链表的方式。
代码【1】
static class HashMapEntry<K, V> implements Entry<K, V> {
//键
final K key;
//值
V value;
//散列值
final int hash;
//下一个节点的引用
HashMapEntry<K, V> next;
}
从 HashMapEntry 成员变量能看出，存了下一个 HashMapEntry 的引用，没有看到其他的逻辑。
既然这样，那就先来看看它是怎样扩容的。doubleCapacity() 中是怎么处理的。
代码【2】
private HashMapEntry<K, V>[] doubleCapacity() {
//新建一个关于旧数组的引用
HashMapEntry<K, V>[] oldTable = table;
//获取旧数组的长度
int oldCapacity = oldTable.length;
if (oldCapacity == MAXIMUM_CAPACITY) {
return oldTable;
}
//两倍扩容
int newCapacity = oldCapacity * 2;
//生成新数组
HashMapEntry<K, V>[] newTable = makeTable(newCapacity);
if (size == 0) {
return newTable;
}
//大佬说这是最优雅的地方，我们来瞅瞅。
for (int j = 0; j < oldCapacity; j++) {
/*
* Rehash the bucket using the minimum number of field writes.
* This is the most subtle and delicate code in the class.
*/
//从旧数组的 0 位置开始查找，空则不考虑。
HashMapEntry<K, V> e = oldTable[j];
if (e == null) {
continue;
}
//每个节点的哈希值与旧容量按位进行运算，得到高位。
//e.hash 代码【3】 highBit //代码【6】
int highBit = e.hash & oldCapacity;
HashMapEntry<K, V> broken = null;
//根据高位与第 j 个位置进行或计算，得到新数组位置。
newTable[j | highBit] = e;
//查找该节点的下一个 HashMapEntry，并且判断在新数组哪个位置。
for (HashMapEntry<K, V> n = e.next; n != null; e = n, n = n.next) {
int nextHighBit = n.hash & oldCapacity;
if (nextHighBit != highBit) {
if (broken == null)
newTable[j | nextHighBit] = n;
else
broken.next = n;
broken = e;
highBit = nextHighBit;
}
}
if (broken != null)
broken.next = null;
}
return newTable;
}
首先说说 代码【3】处，e.hash 是什么。
看看 HashMapEntry 的构造函数。
代码【3】
HashMapEntry(K key, V value, int hash, HashMapEntry<K, V> next) {
this.key = key;
this.value = value;
this.hash = hash;
this.next = next;
}
构造函数只有一个，hash 值是在初始化时传递的。
那么我们就想想什么时候初始化，那应该就是放数据的时候，肯定是发生在加入新的节点时。
代码【4】
public V put(K key, V value) {
……
//看名字仿佛是散列过两次。
int hash = Collections.secondaryHash(key);
HashMapEntry<K, V>[] tab = table;
int index = hash & (tab.length - 1);
for (HashMapEntry<K, V> e = tab[index]; e != null; e = e.next) {
if (e.hash == hash && key.equals(e.key)) {
preModify(e);
V oldValue = e.value;
e.value = value;
return oldValue;
}
}
modCount++;
if (size++ > threshold) {
tab = doubleCapacity();
index = hash & (tab.length - 1);
}
//能看出来是从这添加一个新的节点。
addNewEntry(key, value, hash, index);
return null;
}
void addNewEntry(K key, V value, int hash, int index) {
table[index] = new HashMapEntry<K, V>(key, value, hash, table[index]);
}
果然，就是在这里进行的初始化，就是使用传入的 hash 值，这个 hash 值又是在 secondaryHash() 中得到的。
那么我们去看看 secondaryHash();
代码【5】
public static int secondaryHash(Object key) {
return secondaryHash(key.hashCode());
}
//第一次 key.hashCode() ，是使用 Object 中的 hashCode();
//作用是针对键进行散列，使得算出来的 hashCode 更唯一性。
public int hashCode() {
int lockWord = shadow$_monitor_;
final int lockWordMask = 0xC0000000; // Top 2 bits.
final int lockWordStateHash = 0x80000000; // Top 2 bits are value 2 (kStateHash).
if ((lockWord & lockWordMask) == lockWordStateHash) {
return lockWord & ~lockWordMask;
}
return System.identityHashCode(this);
}
//第二次的 secondaryHash()，是使得对散列过的键值，更均匀的散列在散列表中。
//进行了大量的 移位 与 异或计算，移位使得 高位 与 低位 能更合理的对散列均匀。
private static int secondaryHash(int h) {
h += (h << 15) ^ 0xffffcd7d;
h ^= (h >>> 10);
h += (h << 3);
h ^= (h >>> 6);
h += (h << 2) + (h << 14);
return h ^ (h >>> 16);
}
从上面的分析可以看出，最后进行初始化的 HashMapEntry 中的 hash 值,就是二次散列后的结果。
那么放在散列中的哪个位置呢，就是对应的 index ，index = (table.length - 1) & hash 进行计算得出的。
那么简单画个示意图说明下，只分析了低 8 位的情况。
那么存放新节点基本上就这样了，没有分析如果存放出现冲突的情况，不是本文分析的重点。
下面接着 代码【2】中下半部分继续说，即代码【6】。
代码【6】
for (int j = 0; j < oldCapacity; j++) {
HashMapEntry<K, V> e = oldTable[j];
if (e == null) {
continue;
}
int highBit = e.hash & oldCapacity;//highBit 代码【6】
HashMapEntry<K, V> broken = null;
newTable[j | highBit] = e;
for (HashMapEntry<K, V> n = e.next; n != null; e = n, n = n.next) {
int nextHighBit = n.hash & oldCapacity;
if (nextHighBit != highBit) {
if (broken == null)
newTable[j | nextHighBit] = n;//代码【8】
else
broken.next = n;//代码【10】
broken = e;
highBit = nextHighBit;
}
}
if (broken != null)
broken.next = null;
}
从 0 开始从旧数组中读取数据，先说说 highBit，高位与旧容量进行与计算，因为容量都是 2 的指数，以 8 为例子。
假设旧数组中第一个节点中的 hash 值为 11110000，与 8 - 1 进行 & 计算时为 0 ，0 与 0 进行 | 运算，所以 index 为 0。新数组中还是 0 ，位置没变。
newTable[ j | highBit ] —> newTable[ 0 | 0] —> newTable[0]。
不过如果 第一个节点中的 hash 值为 11111000，那么此时的 highBit 就为 1 换为 10 进制就是 8 。1 再与 8 进行 | 运算，就为 9 了。
newTable[ j | highBit ] —> newTable[ 1 | 8 ] —> newTable[9]。
此时发现位置不一样了是吧。不过光看代码不能感觉什么，如果能想下实图的话那就明白了。
那上个图来说明下，我们只分析了两种情况，其他节点类似，循环的最后一个节点进行判断后结束。
忘了说明：新数组的 此时 index 计算 是当它再次扩容时需要计算时 table.length - 1 = 15 。
所以就是后四位。这次扩容是 oldTable.length - 1 = 7 ，所以是后三位。
是不是发现扩容其实更均匀的把以前一个格子的节点，再分散的新的数组。是不是很机智。
那么肯定要说了，这只是简单地说了，如果每个格子只有一个节点，那么有多个节点呢,是单链表结构呢 ?
那我们继续分析 if (broken == null) 与 if (broken != null) 的情况。
代码【7】
HashMapEntry<K, V> broken = null;
newTable[j | highBit] = e;
for (HashMapEntry<K, V> n = e.next; n != null; e = n, n = n.next) {
//查找下一个节点
int nextHighBit = n.hash & oldCapacity;
//判断该节点高位，如果高位与之前相同，那么查找下一个。
//如果该节点高位不同，则判断 断点是否为null。
if (nextHighBit != highBit) {
//如果为null，则为第一次，需要移动的另外的格子（类似上图中，旧数组:1 -> 新数组:9)
if (broken == null)
newTable[j | nextHighBit] = n;
//如果不为null，则证明之前已经移动过，那么此时需要移动的，就在之前的断点之后继续添加。
else
broken.next = n;
//重置断点位置与高位。
broken = e;
highBit = nextHighBit;
}
}
//最后判断断点是否为 null，为 null 时将下一个 HashMapEntry 引用置为 null。
if (broken != null)
broken.next = null;
主要问题: broken 为什么会切换 ？怎么切换 ？切换之后又是怎样保证在新的位置上形成链表 ？
有时可以先根据结果猜想怎么的条件触发，再反推原理，这样比较好设计的初衷。
只分析一个节点，其他节点类似。假设 oldTable[0] 处节点，单链表长度为 4。1111 0 000（因为此时只需要关心低4位，所以我间隔开了）。
对应代码：
for (int j = 0; j < oldCapacity; j++) {
……
// 根据之前的分析，高位为 0
int highBit = e.hash & oldCapacity;
// j 为 0 , newTable[ 0 | 0 ] = newTable[0]
newTable[j | highBit] = e;
……
}
代码【8】
if (broken == null) 时： 对应代码：
HashMapEntry<K, V> broken = null;
//判断下一个节点是否为 null ，此时不为 null ，对第二个节点 1111 1 000 进行判断。
for (HashMapEntry<K, V> n = e.next; n != null; e = n, n = n.next) {
//计算 nextHighBit
int nextHighBit = n.hash & oldCapacity;
//上一步 highBit = 0 ,nextHighBit = 1 , broken == null,满足判断。
if (nextHighBit != highBit) {
if (broken == null)
//此时 newTable [ 0 | 8] = newTable[8]
newTable[ j | nextHighBit ] = n;
else
broken.next = n;
// broken 指向第一个节点 1111 0 000
broken = e;
//高位改为 1
highBit = nextHighBit;
}
}
//再循环判断没有下一个，退出循环，将 第三个节点 .next 置为 null。
//如果 broken == null ,说明单链表在移动时都移动到新数组同一个位置，所以 断点 为 null ，也不需要置 null。
if (broken != null)
broken.next = null;
代码【9】
对应代码：
//判断下一个节点是否为 null ，此时不为 null ，对第三个节点 1010 1 000 进行判断。
for (HashMapEntry<K, V> n = e.next; n != null; e = n, n = n.next) {
//计算高位
int nextHighBit = n.hash & oldCapacity;
//此时 highBit 为 1 , nextHighBit 也为 1 ，说明不处理，直接跳过，判断第四个节点。
if (nextHighBit != highBit) {
……
}
}
代码【10】
if (broken != null) 时： 对应代码：
//对第四个节点 1011 0 000 进行判断。
for (HashMapEntry<K, V> n = e.next; n != null; e = n, n = n.next) {
//计算 nextHighBit = 0
int nextHighBit = n.hash & oldCapacity;
//上一步 highBit = 1 ,nextHighBit = 0 , broken != null,满足判断。
if (nextHighBit != highBit) {
if (broken == null)
newTable[ j | nextHighBit ] = n;
else
// broekn 为第一个节点。
broken.next = n;
// broken 指向第三个节点
broken = e;
// highBit 改为 0
highBit = nextHighBit;
}
}
broken 的意义，就是存储某一边末端节点的引用：
- 比如我现在在 index = 8 的位置，下一个节点需要重新接回 index = 0 处。
- 那么 broken 就保存之前的那个 index = 0 的最后节点。
- 然后把新节点接在 broken 之后，然后再将 broken 指向 index = 8 的末端节点。
以上分析仅供参考，如果有错误，希望指出，共同进步。
扫一扫
2414
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
