源码分析之Map（二）HashCode详解
Hash的定义
散列(哈希)函数：把任意长度的输入通过散列算法变换成固定长度的输出，该输出就是散列值，是一种压缩映射。hashCode是Object的一个方法，返回的是对象的存储地址。
public int hashCode() { int lockWord = shadow$_monitor_; final int lockWordStateMask = 0xC0000000; // Top 2 bits. final int lockWordStateHash = 0x80000000; // Top 2 bits are value 2 (kStateHash). final int lockWordHashMask = 0x0FFFFFFF; // Low 28 bits. if ((lockWord & lockWordStateMask) == lockWordStateHash) { return lockWord & lockWordHashMask; } //返回的是对象引用地址 return System.identityHashCode(this); }
java中，对hashCode方法进行了重写。
Integer.class：
public static int hashCode(int value) { return value; }
String.class：
public int hashCode() { int h = hash; if (h == 0 && value.length > 0) { char val[] = value; for (int i = 0; i < value.length; i++) { h = 31 * h + val[i]; } hash = h; } return h; }
在名著 《Effective Java》第 42 页就有对 hashCode 为什么采用 31 做了说明：
之所以使用31，是因为他是一个奇素数。如果乘数是偶数，并且乘法溢出的话，信息就会丢失，因为与2相乘等价于移位运算（低位补0）。使用素数的好处并不很明显，但是习惯上使用素数来计算散列结果。
31 有个很好的性能，即用移位和减法来代替乘法，可以得到更好的性能： 31 * i == (i << 5） - i， 现代的 VM 可以自动完成这种优化。这个公式可以很简单的推导出来。
二进制基础知识
<< : 左移运算符，num << 1,相当于num乘以2 低位补0 >> : 右移运算符，num >> 1,相当于num除以2 高位补0 >>> : 无符号右移，忽略符号位，空位都以0补齐 % : 模运算 取余 ^ : 位异或 第一个操作数的的第n位于第二个操作数的第n位相反，那么结果的第n位为1，否则为0 & : 与运算 第一个操作数的的第n位于第二个操作数的第n位如果都是1，那么结果的第n位为1，否则为0 | : 或运算 第一个操作数的的第n位于第二个操作数的第n位 只要有一个是1，那么结果的第n位为1，否则为0 ~ : 非运算 操作数的第n位为1，那么结果的第n位为0，反之，也就是取反运算（一元操作符：只操作一个数）
HashMap中hash算法原理
static final int hash(Object key) { int h; return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16); }
为什么要右移16位然后异或呢?
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;
}
假设有一种情况，对象 A 的 hashCode 为 1000010001110001000001111000000，对象 B 的 hashCode 为 0111011100111000101000010100000。如果数组长度是16，也就是 15 与运算这两个数
1000010001110001000001111000000
&0000000000000000000000000001111
--------------------------------
0000000000000000000000000000000
0111011100111000101000010100000
&0000000000000000000000000001111
--------------------------------
0000000000000000000000000000000
会发现结果都是0。这样的散列结果太让人失望了。很明显不是一个好的散列算法。但是如果我们将 hashCode 值右移 16 位，也就是取 int 类型的一半，刚好将该二进制数对半切开。并且使用位异或运算（如果两个数对应的位置相反，则结果为1，反之为0），这样的话，就能避免我们上面的情况的发生
HashMap 为什么使用 (&) 与运算代替模运算
根据hash计算下标的方法 tab[(n - 1) & hash] ，n 是数组的长度。其实该算法的结果和模运算的结果是相同的。但是，对于现代的处理器来说，除法和求余数（模运算）是最慢的动作。
a % b == (b-1) & a ,当b是2的指数时，等式成立。
HashMap 的容量为什么建议是 2的幂次方
接上面的，当 n 为 2 的幂次方的时候，减一之后就会得到 1111* 的数字，这个数字正好可以掩码。并且得到的结果取决于 hash 值。因为 hash 值是1，那么最终的结果也是1 ，hash 值是0，最终的结果也是0
自定义 HashMap 容量最好是多少
如果Map中已有数据的容量达到了初始容量的 75%，那么散列表就会扩容，而扩容将会重新将所有的数据重新散列，性能损失严重，所以，我们可以必须要大于我们预计数据量的 1.34 倍，如果是2个数据的话，就需要初始化 2.68 个容量。当然这是开玩笑的，2.68 不可以，3 可不可以呢？肯定也是不可以的，我前面说了，如果不是2的幂次方，散列结果将会大大下降。导致出现大量链表。那么我可以将初始化容量设置为4。 当然了，如果你预计大概会插入 12 条数据的话，那么初始容量为16简直是完美，一点不浪费，而且也不会扩容
参照：https://blog.csdn.net/qq_38182963/article/details/78940047
