前言
关于HashMap的详解文章请移步:深度剖析HashMap一篇文章就够了
关于面试官的其他问题请移步:
为什么初始容量是 2次幂?
jdk1.8 的 putVal()
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
// 如果没有hash碰撞则直接插入元素
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
......
}
}
通过看源码,我们发现,判断桶的索引的实现是 i = ( n - 1 ) & hash,其中 n 是 map 的容量。
任何 2 的整数幂 - 1 得到的二进制都是 1,如:16 - 1 = 15(1111);32 - 1 = 31(11111)
而 n-1 与 hash 做的是与运算(&),与运算是 两个都为1,才为1
既然我们的 n-1 永远都是 1,那 ( n - 1 ) & hash 的计算结果就是 低位的hash 值。如:
00100100 10100101 11000100 00100101 // Hash 值
& 00000000 00000000 00000000 00001111 // 16 - 1 = 15
----------------------------------
00000000 00000000 00000000 00000101 // 高位全部归零,只保留末四位。
那容量不是 2次幂会怎么样?我们来做个试验。
2次幂的情况:
hash | (n-1)& hash | 结果 |
---|---|---|
0 | 1111 & 0 | 0 |
1 | 1111 & 1 | 1 |
2 | 1111 & 10 | 2 |
3 | 1111 & 11 | 3 |
4 | 1111 & 100 | 4 |
5 | 1111 & 101 | 5 |
6 | 1111 & 110 | 6 |
… … | … … | … … |
非2次幂的情况,假设 n = 10
hash | (n-1)& hash | 结果 |
---|---|---|
0 | 1100 & 0 | 0 |
1 | 1100 & 1 | 0 |
2 | 1100 & 10 | 0 |
3 | 1100 & 11 | 0 |
4 | 1100 & 100 | 4 |
5 | 1100 & 101 | 4 |
6 | 1100 & 110 | 4 |
… … | … … | … … |
对比来看,哪种发生哈希碰撞的概率更低一目了然,如果 n 为 2次幂,可以保证数据的均匀插入,降低哈希冲突的概率,毕竟冲突越大,代表数组中的链表/红黑树越大,从而降低Hashmap 的性能。
扰动函数
HashMap 中的扰动函数是一个通过对 key 值类型自带的哈希函数生成的散列值进行位移计算来扰乱散列值,以达到降低哈希碰撞的概率的方法。源码中对应的是 hash(),但具体是如何进行移位和降低碰撞概率的??
// jdk 8
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
我们分析一下hash(),key.hash() 调用的是key类型自带的哈希函数,返回的是 int 类型的散列值。
如果没有扰动函数的情况下,我们拿着散列值作为下标找到 hashmap 中对应的桶位存下即可(不发送哈希冲突的情况下),但 int 类型是 32 位,很少有Hashmap的数组有40亿这么大,所以, key 类型自带的哈希函数返回的散列值不能拿来直接用。如果我们取低几位的 hash 值来做数组映射行不行,但是如果低位相同,高位不同的 hash 值就碰撞了,如:
// Hash 碰撞示例:
00000000 00000000 00000000 00000101 & 1111 = 0101 // H1
00000000 11111111 00000000 00000101 & 1111 = 0101 // H2
为了解决这个问题,HashMap 想了个办法,用扰动函数降低碰撞的概率。将 hash 值右移16位(hash值的高16位)与 原 hash 值做异或运算(^),从而得到一个新的散列值。如:
00000000 00000000 00000000 00000101 // H1
00000000 00000000 00000000 00000000 // H1 >>> 16
00000000 00000000 00000000 00000101 // hash = H1 ^ (H1 >>> 16) = 5
00000000 11111111 00000000 00000101 // H2
00000000 00000000 00000000 11111111 // H2 >>> 16
00000000 00000000 00000000 11111010 // hash = H2 ^ (H2 >>> 16) = 250
H1,H2 两个 hash 值经过扰动后,很明显不会发生碰撞。
总结
总的来说,不管是规定 Hashmap 的 n 为 2次幂,还是扰动函数,都是为了一个目标,降低哈希冲突的概率,从而使 HashMap 性能得到优化。而规定 n 为 2次幂,是在新建 Hashmap对象初始化时,规定其容量大小的角度来优化。而扰动函数是插入 key 值时改变 key 的散列值来达到优化效果。