HashMap（JDK1.8）

• 数据结构：数组+链表+红黑树（Java8）

• 原理

底层采用链表数组，链表的长度达到8（为什么是8？因为链表长度遵循泊松分布）的时候可能就会转换为红黑树，而且要树化，数组容量必须达到64，即需要两次扩容；当输节点数减少到6的时候，就会进行反树化，变成链表；

链表长度的泊松分布：
* 0:    0.60653066
* 1:    0.30326533
* 2:    0.07581633
* 3:    0.01263606
* 4:    0.00157952
* 5:    0.00015795
* 6:    0.00001316
* 7:    0.00000094
* 8:    0.00000006

由此可知，如果出现了红黑树，说明hash值不够离散

初始容量为：2^4，要求容量为2^n；而Hashtable初始化容量大小为11，且都为素数（满足了除法散列法的推荐值）；
所以操作HashMap主要分两步：
1.在数组中找到正确的链表；
2.在链表中找到正确的元素（遍历链表）；

而对于上面的第1步，又分两个步骤：
hash ：该方法主要是将Object转换成一个整型；
indexFor ：该方法主要是将hash生成的整型转换成链表数组中的下标（使用除法散列法，即取模运算）；到了jdk8时，在这步骤之前还加入了高位运算，以减少碰撞提升效率（其实就是减少链表长度）；
在jdk8中，在put方法的实现里还做了优化，当链表长度大于8时，加入了红黑树；

• 算法

        1）hash计算

static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }

         2）put

public V put(K key, V value) {
        return putVal(hash(key), key, value, false, true);
    }

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        //初始化table
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        //取值或者取链表或者红黑树
        //没有冲突时
        if ((p = tab[i = (n - 1) & hash]) == null)
            //初始化node
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
            //1. 根据下标取出节点的hash值必须等于传入的key对应的hash值
            //2. a. 用==比较传入的key和p.key是否是同一个对象 b. 如果a不满足，且key不为null时，则利用key.equals方法比较是否相等
            //找到相同key值的节点，且头部节点就是key对应的原节点
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            else 
            //是树的情况
            if (p instanceof TreeNode)
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            //不存在相同key，那么就要开始遍历链表，并插入到链表的尾部
            else {
                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;
                    }
                    //找到相同key值的节点
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            //找到key对应有旧的不为bull的元素
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }

3）扩容

容量每次扩大一倍，这是为了性能；扩容后，hash值虽不用重新计算，但是在数组中的位置可能会发生变化，如果每次扩容一倍的话，元素位置只有两种可能：1. 位置不变； 2. 当前位置+原有容量；

下面有一个示例来解释扩容过程：

 扩容其实就是元素下标从新确定的过程，后文中指出：一个容量为2^n的hash数组上元素的位置，实际是取这个元素上key.hash值的二进制形式的低n位。

那么，进行一次扩容，实际上就是取低n+1位，即：
        新的下标 = 原来的下标 + 2^n * 第n+1位的二进制值;

例如：

容量：2^5 
hash：0000 0000 0000 0011 0001 0101 0111 1010 
下标：11010 = 26

扩容一次后的下标：1 11010 = 26 + 2^5 * 1 = 26 + 32 ，

类似地，
hash：0000 0000 0000 0011 0001 0101 0101 1010
扩容一次后的下标：0 11010 = 26 + 2^5 * 0 = 26 

• 为什么HashMap的容量要设置为2^n？

因为计算数组下标使用到取模运算，又因为如下公式的存在：X % 2^n = X & (2^n – 1)，可以将取模运算转化为与运算，提升cpu效率，所以要求除数为2^n的形式；

为什么X % 2^n = X & (2^n – 1)？

由于除数是2^n的形式，其二进制如下形式：……000001000……，取模运算时，我们把被除数当作2^n进制的数，那么做完除法之后剩下都是小于2^n的部分，对应到二进制形式就等于被除数右边的m位（m = 除数中“1”右边“0”的个数)

例如： 202106 % 32
转化为二进制：0000 0000 0000 0011 0001 0101 0111 1010 % 0010 0000
用上面的方式直接目测出来m = 5，所以余数为：11010，即26

由上述计算，不难得出一个结论：对一个整数进行取模运算，如果它的除数满足2^n的形式，那么它的余数等于被除数二进制形式的低n-1位；放在计算机学科中，就是取低n-1位的值。

• 为什么要加入高位运算呢，为什么是异或运算？

        实际上，HashMap在散列时的做法违背了算法本来的初衷，不应该用2^n的数作为除数，而应该用素数，正如上面提到的，使用2^n的形式能提升下标值的运算速度，但同时也只能利用的hash值的低位，这大大的增加了碰撞几率，所以要想办法把高位也利用起来，就能有效减小碰撞，即减小链表长度；

        为什么要用异或运算呢？因为异或出现0和1的概率是均等的，而与运算出现0的概率是0.75，出现1的概率是0.25，或运算出现0的概率是0.25，出现1的概率是0.75；

• 负载因子对性能的影响，为什么默认值时0.75，还不建议修改？

1. 负载因子相对越小一些，碰撞概率就小，那么读取效率相对就高，但是更耗费内存，但数组空间变得特别大的时候，扩容过于频繁，反过来也会减低效率；

2. 0.75是设计人员通过计算得出的科学临界值，均衡了性能和成本；真实理论值其实是log2≈0.69，但由于临界值（threshold） = 负载因子（loadFactor） * 容量（capacity），capacity是2^n，故而loadFactor取0.75更容易能得到整数的threshold；

实际运用中，我们一般把容量设置为：预估实际容量 / 0.75 + 1，以减小扩容次数；

• 高并发情形下出现死锁

在扩容过程中，多线程同时put很多元素有可能会形成环形链表，调用get方法时就导致循环死锁，cpu100%；

• JDK1.8为什么要加入红黑树

1 解决链表遍历效率问题；
2 防止线程安全情况下的Dos（拒绝服务）
         tomcat使用HashMap来存储接收到的HTTP参数，heike就可以利用这一点进行Dos攻击
         假设模拟2万个hash值相同的字符串（因为java覆写了String类型的hashCode方法），将这些值作为key传给服务器，这时存储参数的HashMap的链表长度就达到2万，此时遍历链表的效率低，如果发起大量这样的请求就导致cpu一直在遍历链表而满载。

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;
    }

• 为什么是红黑树？

由于旋转输比较消耗性能，这是一种这种的方案，满足如下条件：最高处的长度<=2*最低处的长度

• 注意事项

不要在 foreach 循环里进行元素的 remove/add 操作。 remove 元素请使用 Iterator方式，如果并发操作，需要对 Iterator 对象加锁；

使用 entrySet 遍历 Map 类集合 KV，而不是 keySet 方式进行遍历；