面试官：为什么默认初始容量为2次幂？不是2次幂会怎样？讲讲 HashMap 扰动函数？

前言

关于HashMap的详解文章请移步：深度剖析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 的散列值来达到优化效果。