HashMap源码学习和总结
如何计算key的hash值
static final int hash(Object key) { int h; return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16); }
计算hashCode()后的h与h逻辑右移16位的结果异或作为hash值
>>>：无符号右移，将h的二进制数整体右移16位，超出的去掉，左侧空位用0补齐（int型是4字节32位）
举例：
key="java"
h = key.hashCode() ：3254818
二进制：11 0001 1010 1010 0010 0010 （22位，不足32位）
补齐完整的32位：0000 0000 0011 0001 1010 1010 0010 0010 ------ （1）
h>>>16：0000 0000 0000 0000 0000 0000 0011 0001 -------（2）
^ ：对（1）和（2）异或操作，相同为0，不相同为1，可以理解为不进位相加，结果为0000 0000 0011 0001 1010 1010 0001 0011
问题：为什么要设计 右移16位再异或的算法
右移16位后，可以让h的低16位和高16位都参与运算，这样计算出来的最终的hash值更"散"，更散意味着更小的hash碰撞，更低的hash冲突
问题：异或（^）相比&，| 有什么优势？
& 很明显，只有1 & 1的结果才是1，其他都是0，这样计算二进制结果肯定都向0 聚集
| 也很明显，只要有1参与运算，结果都是1，只有0|0才是0，这样计算的二进制结果都会向1聚集
^ 不考虑2个二进制的先后位置，如果是0，说明2个位都是0或1，如果是1，说明两个分别是0和1，至于是谁的无所谓
如何计算新key-value落在数组的哪个下标位置
i = (n - 1) & hash
这个结果实际就是hash%n (n是2的x次幂)
为什么不直接用hash%n ？因为取模运算的效率远低于&运算
为什么每次数组扩容后长度设计为2的N次幂 ？因为设计为2的N次幂，才能使得（n-1）& h 与h%n相等，才能用 按位与 代替 % 运算，提高效率
计算推导：
先举一个例子
100 / 8 = 12 100 % 8 = 4 使用二进制位运算，除以8[2 ^ 3]就是向右移了3位 0110 0100 >> 3 = 0000 1100[100] 0000 1100 = 12 就是商 100 = 4 就是余数 也就是0110 0100的后3位：100
假设n=2 ^ m，除以2 ^ m就是右移m位，得到的结果就是商，移出来的m位二进制转10进制，就是余数（模）
问题转化为：需要将商对应的位全部忽略掉，而余数对应的位数全部保留下来
应该想到h & (00000111) ，就是说h需要和这样的二进制做运算：先是连续的0，后是连续的1，假设有K个连续的1
根据数学里的等比数列通项公式，计算结果为1*2^0+1*2^1+1*2^2+........+1*2^（k-1）=2^k-1
也就是说h要和2^k-1这样的数做&运算，这样的数二进制是 00...011...1，连续的0和连续的1的形式
如果N是2^k，这个设计就OK了，因此，数组的长度扩容时总是为2的N次幂
Node和TreeNode的结构
单链表的节点
static class Node<K,V> implements Map.Entry<K,V> { final int hash; final K key; V value; Node<K,V> next; Node(int hash, K key, V value, Node<K,V> next) { this.hash = hash; this.key = key; this.value = value; this.next = next; } }
红黑树的节点
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> { TreeNode<K,V> parent; // red-black tree links TreeNode<K,V> left; TreeNode<K,V> right; TreeNode<K,V> prev; // needed to unlink next upon deletion boolean red; TreeNode(int hash, K key, V val, Node<K,V> next) { super(hash, key, val, next); } }
红黑树的定义 ：自平衡二叉查找树，只有红黑节点，根和叶子节点都是黑节点，红的两个儿子节点都是黑，从任一节点到其叶子节点的每条路径上的黑节点个数相同
插入，删除，查找的时间复杂度为O(logn)
JDK8 链表尾插法
for (int binCount = 0; ; ++binCount) { if ((e = p.next) == null) { p.next = newNode(hash, key, value, null); if (binCount >= TREEIFY_THRESHOLD - 1){ // -1 for 1st treeifyBin(tab,hash); }
break; } if (e.hash == hash &&((k = e.key) == key || (key != null && key.equals(k)))){ break; } p = e; }
p是这个for循环里的当前节点，初始值为p = tab[i = (n - 1) & hash]，从头节点开始遍历
newNode(hash, key, value, null)是要插入的节点
当p.next==null的时候，插入尾巴，表明是尾插法
当遇到某个节点key就是要插入的这个key时，直接break；
否则继续迭代遍历
关于JDK7中头插法导致链表成环的分析，这位老铁写的非常清楚细致：https://blog.csdn.net/fengyuyeguirenenen/article/details/122760014
贴几个图理解下（网上画的比较清晰的图）
线程不安全的问题
线程安全问题，从状态溢出的角度着手，状态就是类的属性，主要是table数组：transient Node<K,V>[] table;
put的时候value覆盖，代码位置为
if ((p = tab[i = (n - 1) & hash]) == null) tab[i] = newNode(hash, key, value, null);
逻辑比较清晰，判空后赋值操作，典型的线程安全问题
