HashMap数据结构
HashMap是以数组+链表的形式进行存储数据。
数组的优缺点：通过下标索引方便查找，但是插入或删除慢。
链表的优缺点：查找一个元素需要以遍历链表的方式查找，但是插入或删除快。
HashMap内部维护了一个Node数组：
其中Node数据结构如下：
HashMap构造方法
HashMap数组默认大小是16，负载因子是0.75。
当创建HashMap集合对象的时候，在jdk8以前，构造方法中会创建一个长度为16的Entry[] table。在jdk8以后不是在HashMap的构造方法创建数组了，是在第一次调用put方法时创建数组--Node[] table。
HashMap，tableSizeFor(Object key)
static final int tableSizeFor(int cap) { int n = cap - 1; n |= n >>> 1; n |= n >>> 2; n |= n >>> 4; n |= n >>> 8; n |= n >>> 16; return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1; }
由于HashMap的 capacity 都是2的幂，因此这个方法用于找到大于等于initialCapacity的最小的2的幂(如果initialCapacity就是2的幂，则返回的还是这个数)。
HashMap中，数组的最大长度是1 << 30，所以采用上面的算法，一定返回一个从cap中有效位数开始，后面全部变成1的数(比如：00010101会变成00011111)。
注意：第一步用cap - 1，是为了防止cap已经是2的幂，如果不执行这个减1操作，则执行完后面的无符号右移操作之后，返回的capacity将是这个cap的2倍。
HashMap，hash(Object key) --- 计算key的hash值
static final int hash(Object key) { int h; return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16); }
1、如果 K 是空，则 hash 值为0，这也就是为啥 HashMap 的 K 可以是空。
2、不同的 K 的hashCode值可能相同。
3、在计算数组下标时，计算公式是 (tab.length - 1) & hash) 。如果数组长度很小(比如是16)，那么length - 1即为 00001111，这样的值和 hashCode 直接进行按位与运算，实际上只用到了 hashCode 的后4位。如果当 hashCode 的高位变化很大，低位变化很小，这样就很容易发生 K 碰撞。这里将 hashCode 值右移16位，刚好将该二进制数对半切开，并且使用位异或运算，相当于使用 hashCode 的高16位打乱 hashCode 的低16位。这样就降低了 K 碰撞的几率(称为扰动函数)。
例如：
两个 hashCode 值，后四位相同：1111 1111 1111 1111 1111 0000 1110 1010 、111 0101 1111 1001 1111 0000 1110 1010
计算数组下标 (tab.length - 1) & hash) ：
a、如果高位不参与运算，直接得到：0000 0000 0000 0000 0000 0000 1010 、0000 0000 0000 0000 0000 0000 1010 ==>发生碰撞
b、如果高位参与运算：
先进行高低位 ^ 运算，得到：1111 1111 1111 1111 0000 1111 0001 0101、1111 0101 1111 1001 0000 1010 0001 0011
再进行 & 运算，得到：0000 0000 0000 0000 0000 0000 0000 0101、0000 0000 0000 0000 0000 0000 0000 0011 ==>未发生碰撞
HashMap，put(K key, V value) --- 添加元素
public V put(K key, V value) { return putVal(hash(key), key, value, false, true); }
执行步骤：
1、调用 hash(K) 方法计算K的 hash 值，然后结合数组长度 (tab.length - 1) & hash 得到数组下标。
2、如果 K 的 hash 值在HashMap中不存在，则直接将数据插入到数组中。若存在，则发生碰撞。
3、如果 K 的 hash 值在HashMap中存在，则比较两者 K 的 equals。
a、equals 返回 true，则将该键替换成新值value。
b、equals 返回 false，则新建一个Node节点，并插入到链表的尾部(尾插法)或者红黑树中。
其中，上面的b，是采用遍历当前链表。如果链表长度大于8，则判断数组长度是否大于64，大于64则转为红黑树，否则扩容。
4、判断数组中实际节点个数是否大于threshold，如果大于则扩容。
HashMap，resize() --- 扩容
当HashMap中元素越来越多时，碰撞的几率也就越来越高(数组长度是固定的)。所以为了提高效率(增删改查)，就要对HashMap中的数组进行扩容。
final Node<K,V>[] resize() { 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 }
...
1、扩容时，会将 table 长度变为原来的两倍(注意是 table 长度，而不是 threshlod )。
2、扩容时，会重新计算旧数组中节点的位置。节点在新数组中的位置只有两种情况：
a、原下标
b、原下标 + 旧数组长度
因此，在HashMap扩容时，是不需要重新计算 hash 值的，直接将原hash & 新数组长度即可。
HashMap，get(Object key)
public V get(Object key) { Node<K,V> e; return (e = getNode(hash(key), key)) == null ? null : e.value; }
执行步骤：
1、计算目标节点的hash值，并通过 (tab.length - 1) & hash 得到数组下标(这一步和 put 方法一样)。
2、判断下标，得到首节点。判断首节点是否为空，为空则直接返回空。
3、判断首节点 K 与目标节点的的 hash 是否相同，equals 方法是否相同，相同则直接返回首节点。
4、上一步如果不相同，判断首节点的下个节点是否为空，为空则直接返回空。
5、判断首节点是否为红黑树：
a、如果是，则通过红黑树取值并返回
b、如果不是，则遍历链表，直到 hash 值和 equals 相等则跳出返回
HashMap数组长度为啥要是2的幂？
在 put 元素时，需要计算 K 在数组中的下标，计算公式是 (tab.length - 1) & hash。只有数组长度是2的幂，减1后得到的二进制才全部是1。
例如16，减1后就是15，二进制为00001111)，这样进行 & 运算时，二进制的每一位都是有效的(如果后面的4位中有个0，进行 & 运算后就还是0，这一位对应的数组下标就永远不会有元素，这样就增加了碰撞的几率)。
HashMap发生扩容的时机有哪些？
a、put元素，数组为空时(第一次put时)
b、put元素，数组中实际节点个数大于 threshold 时
c、put元素，发现链表长度超过8，且数组长度小于64时
HashMap初始化时，如何指定初始化大小？
a、如果无法确定元素个数，那么使用默认值(16)即可。
b、如果可以确定元素个数，initialCapacity = (需要存储的元素个数 / 负载因子) + 1。注意负载因子（即loader factor）默认为0.75。
HashMap会发生死循环？
多线程环境下：
jdk1.7在进行扩容操作时，会重新定位每个节点的下标，并采用头插法将节点迁移到新数组中。头插法会将链表的顺序翻转，有可能会出现两个节点成为循环链表(双方节点的next都指向对方)，最终造成死循环。
jdk1.8是直接在 resize 函数中完成了数据迁移，并且jdk1.8在进行元素插入时使用的是尾插法，所以不会有死循环的问题。
HashMap为啥线程不安全？
多线程环境下：
在进行 put 操作时，会发生数据覆盖的情况。主要体现在两点：
a、假设两个线程A、B都在进行put操作，并且 hash 函数计算出的插入下标是相同的，当线程A执行完下面代码后由于时间片耗尽导致被挂起，而线程B得到时间片后在该下标处插入了元素，完成了正常的插入，然后线程A获得时间片，由于之前已经进行了 hash 碰撞的判断，所有此时不会再进行判断，而是直接进行插入，这就导致了线程B插入的数据被线程A覆盖了，从而线程不安全。
b、插入数据完成后，++size 非原子操作，可能后面的线程会覆盖前一个线程的操作。
ConcurrentHashMap如何保证线程安全？
ConcurrentHashMap成员变量使用 volatile 修饰，避免指令重排序，同时保证内存可见性。另外使用 CAS (引入Unsafe对象)和 synchronized 进行赋值操作，多线程操作只会锁住当前操作索引的节点(即对应链表)。
HashMap的链表转为红黑色的阈值是8，红黑色转链表阈值是6，为什么这么设计？
通过计算，发生 hash 碰撞8次的几率为0.00000006，所以8基本够用了(转为红黑色的概率很低)。
至于为什么转回来是6，因为如果 hash 碰撞次数在8附近徘徊，会一直发生链表和红黑色的转化，为了预防这种情况发生。