前言
本文的解析基于JAVA8,由于HashMap内部机制较为复杂,本章介绍HashMap的下标计算过程和resize()函数。包含空间开辟,特征保留,冲突分析,链表重组原理等内容。
1.下标计算
计算key.hashCode()并将哈希值的高位与低位做异或。
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
JAVA7之中其实是四次异或,在JAVA8之中已经做了简化了。其原理是不变的
- 首先要说明的是key.hashCode()函数调用的是key自带的哈希函数,返回Int型散列值,但是如果直接拿散列值作为下标访问HashMap数组的话,映射空间就为**-2147483648到2147483648**,即为40亿的映射空间,但是这个长度的数组内存是放不下的。所以要对数组的长度取模运算。即散列值和数组的长度-1做与操作,代码如下。
(n - 1) & hash
n为length
- 其次要说明的是为什么HashMap的长度要取2的整次幂,因为长度-1正好相当于一个低位掩码。“与”操作的结果就是散列值的高位全部归零,只保留低位值,用来做数组下标访问。以初始长度16为例,16-1=15。2进制表示是00000000 00000000 00000000 00001111。和某散列值做与操作如下,结果就是截取了最低的四位值。过程如下。
11011111 01111110 10101111 11010101
& 00000000 00000000 00000000 00001111(n-1)
------------------------------------------------------
00000000 00000000 00000000 00000101
- 根据结果看到,其实保留的就是最低的四位值。如果直接拿此值去当作下标,显然碰撞会十分严重。如果是等差数列形的分布,最后几位为规律性重复,则误解。此时扰乱函数的作用就体现出了。过程如下。
step1:调用key.hashCode()并复制给h
11011111 01111110 10101111 11010101 [h = key.hashCode()]
------------------------------------------------------------------
step2:将h的高位与低位做异或(与无符号右移的h做异或)
11011111 01111110 10101111 11010101 [h]
00000000 00000000 11011111 01111110 [h >>> 16]
00000000 00000000 01110000 10101011 ^
------------------------------------------------------------------
step3:将结果与n(数组长度)-1做与
00000000 00000000 01110000 10101011
00000000 00000000 00000000 00001111 &
------------------------------------------------------------------
00000000 00000000 00000000 00001011
- 扰乱函数很巧妙的通过16位无符号右移,让自己的高低位做异或,使高低位做特征对比,保留了部分高位的特征,也加大了结果的随机性。然后与(n-1)做与操作,结果也就是保留了最低的四位。
最后在引用一篇An introduction to optimising a hashing strategy。作者随机选取了352个字符串,在他们散列值完全没有冲突的前提下,对它们做低位掩码,取数组下标。结果如下。
当HashMap长度为512位,如果取低9位,没有扰动函数,有103次碰撞。加入扰乱函数则降低为92次。减少近10%
JAVA8把扰乱函数从四次降低为一次,侧面印证了多做几次意义不大。
2.resize()
resize()内部逻辑还是较为复杂的,我们把方法分为多个部分,我们分段解析。
final Node<K,V>[] resize() {
//------1.空间开辟begin------
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
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);
}
if (newThr == 0) {
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?(int)ft : Integer.MAX_VALUE);
}
threshold = newThr;
@SuppressWarnings({"rawtypes","unchecked"})
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
//------1.空间开辟end------
//------2.重新分配节点到对应位置begin------
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
//------2.1数组分配begin------
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;
//------2.1数组分配end------
//------2.2红黑树分配begin------
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
//------2.2红黑树分配end------
//------2.3链表分配begin------
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;
}
}
}
//------2.3链表分配end------
}
}
return newTab;
//------2.重新分配节点到对应位置end------
}
此段代码是reseize()方法全貌,我们分为如下几个分段:
- 重新开辟容量大小计算过程
- 重新分配节点到对应位置
- 数组分配
- 红黑树分配
- 链表分配
1.创建新数组
在HashMap初始化和扩容的时候都会调用此方法,首先第一段为根据具体情况计算出需要创建的HashMap的容量和扩容阈值。下文解析会围绕两种情况做出分析。
//1为无initialCapacity初始化容量
//2为指定了initialCapacity初始化容量
//3为扩容
//获取旧table的引用,长度,容量,扩容阈值
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
//创建新的容量,阈值的变量
int newCap, newThr = 0;
if (oldCap > 0) {
//3
if (oldCap >= MAXIMUM_CAPACITY) {
//如果旧容量大于容量最大限制则给扩容阈值设置为Integer.MAX_VALUE
//并返回旧table
threshold = Integer.MAX_VALUE;
return oldTab;
}
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY)
//3
//对新容量赋值为旧容量的2倍
//如果新容量小于容量最大限制,并且旧容量大于或等于默认容量(16)则给新扩容阈值同赋值为旧容量的2倍
newThr = oldThr << 1;
}else if (oldThr > 0)
//2
//如果指定了initialCapacity,则threshold为大于initialCapacity的最小的2的次幂
//(oldThr > 0)为如果指定了initialCapacity,则用threshold作为table的实际大小
newCap = oldThr;
else {
//1
//如果没有指定initialCapacity,则为默认空间大小
//并且扩容阈值赋值为扩容因子*默认空间大小
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
if (newThr == 0) {
//1
//为扩容阈值赋值为新容量的0.75倍(小于最大容量的情况)
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ? (int)ft : Integer.MAX_VALUE);
}
//根据计算出的容量创建新的数组,并更新阈值
threshold = newThr;
@SuppressWarnings({"rawtypes","unchecked"})
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
最后总结如下
- 如果在初始化情况下,并构造函数没有指定initialCapacity,则进入分支1,table大小为16,扩容阈值为16*0.75。
- 如果在初始化情况下,并构造函数指定了initialCapacity,则进入分支2,则table大小为threshold, 即大于指定initialCapacity的最小的2的整数次幂。
- 如果是扩容情况,则进入分支3,对新容量赋值为旧容量的2倍。
2.赋值过程
2.1 纯数组情况
赋值过程其实是通过节点迭代完成的,只不过内部有分为三种情况处理,我们本段解析先说明是如何通过next添加到纯数组的结构(也就是没有hash冲撞的情况)。
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
//创建节点
Node<K,V> e;
//e赋值迭代节点
if ((e = oldTab[j]) != null) {
//如果迭代的节点不NULL
//给迭代节点制空,CG回收
oldTab[j] = null;
if (e.next == null) newTab[e.hash & (newCap - 1)] = e;//如果e节点的.next节点为空,则为纯数组,直接通过下标添加。
}
//后续代码从此继续
}
}
2.2 链表情况
此段代码极为复杂,首先先说出大体的逻辑。
- 根据上文分析,如果next节点为空则等于在此下标下有多个元素(链表结构),并且不等于红黑树会进入此分支
- 下段代码会通过某种方式确定新HashMap(扩容后的HashMap)那些节点是下标没有发生变化的,那些是发生变化的,并根据放置到两组不同的链表之中。
- 最终通过某种方式把两组链表添加至两个对应下标
此时我们有两个问题
- 插入到不同链表的条件?
- 如何计算两组链表要添加到的下标?
![2076773863-5b5e7d6916752_articlex](C:\Users\D\Desktop\2076773863-5b5e7d6916752_articlex.png)//lo链表的头节点和尾节点
Node<K,V> loHead = null, loTail = null;
//hi链表的头节点和尾节点
Node<K,V> hiHead = null, hiTail = null;
//迭代节点
Node<K,V> next;
do {
next = e.next;
if ((e.hash & oldCap) == 0) {//关键点
//插入至lo链表
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
else {
//插入到hi链表
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
if (loTail != null) {
//如果lo链表不为空则添加到[j]位
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {
//如果hi链表不为空则添加到[j+oldCap]位
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
根据源码分析,得到结果。
-
((e.hash & oldCap) == 0)将节点插入到lo链表,否则添加到hi链表。下文做出此条件的分析。
首先要明确几点:
- oldCap一定是2的整数次幂, 假设是2^m
- newCap是oldCap的两倍, 则会是2^(m+1)
- hash对数组大小取模**
(n - 1) & hash
** 其实就是取hash的低m
位
所以假设oldCap为32,newCap为64,即:
oldCap=32 oldCap-1=31 0000 0000 0000 0000 0000 0000 0001 1111 ---------------------------------------------------------------------- newCap=64 newCap-1=63 0000 0000 0000 0000 0000 0000 0011 1111
此时,(newCap-1&hash)的结果只可能是首位是0或者是1加任意四位0或1,假设结果是011010和111010两种情况,得出以下两种结论。
- 结果为011010则和(oldCap-1&hash)结果一致,即位置不变,为lo链表,下标为j
- 结果为111010则和(oldCap-1&hash)+10000一致,即位置发生变化,hi链表,下标为j+oldcap
图解如下