分析分析HashMap

1.HashMap 数据结构

数组加链表
数组的结构大概是这样的

当我们put<k,v>值进去的时候 HashMap会根据key进行一个hash算法去计算一个值与数组长度（n-1）做与&运算 算出index ，这个index类似数组地址位置。

//进行hash算法
static final int hash(Object key) {
        int h;
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }
 //put方法内部逻辑   省略很多
   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;
        if ((p = tab[i = (n - 1) & hash]) == null)
        		// i =(n - 1) & hash  算出key的下标位置
            tab[i] = newNode(hash, key, value, null);  
            

由于hash 2个不同的key 有概率会导致hash值一样
例如put（k1,v1）和put（k2,v2） 有可能出现hash（k1） ==hash（k2）
这时候就需要用到链表的结构了。这个时候put（k2,v2） 就会加入到链表当中。

链表中的每个节点 Node <k,v> 都会有hash key 和value 以及指向的下个节点

static class Node<K,V> implements Map.Entry<K,V> {
        final int hash;
        final K key;
        V value;
        Node<K,V> next;//指向的节点
        ....
        }

2 头插法 和尾插法

在java8之前 新的加入的节点采用的是头插法 就是说新加入的节点会取代原来的值，其他值顺着链表往后移动。
原因 ：作者认为 新插入的值被查找的几率更大。这样可以提升查找效率。
但是在java8之后采用的是尾插法 、
主要原因 ：头插法有个弊端 在多线程插入的时候由于当数组进行扩容的时候resize（） 多个线程put 时候可能会出现环形链表如果这个时候去取值，悲剧就出现了——Infinite Loop。

Java7在多线程操作HashMap时可能引起死循环，原因是扩容转移后前后链表顺序倒置，在转移过程中修改了原来链表中节点的引用关系。
Java8在同样的前提下并不会引起死循环，原因是扩容转移后前后链表顺序不变，保持之前节点的引用关系

3.扩容

扩容主要是负载因子LoadFactor和 当前hashmap长度Capacity 有关系 就是 负载因子 * hashmap容量 < Capacity 就会进行扩容resize（）

1.创建一个新的数组 这个数组的大小是原来的长度的2倍。
2.重新 hash原来的数组内容   把旧的数组重新加到新数组
重新进行hash算法 是因为在上面有提到  key的位置不仅和hash（）这个方法有关还和数组长度有关所有需要重新计算位置。

 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) {
            //如果大于hashmap容量最大值则不扩容了
            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
        }
        else if (oldThr > 0) // initial capacity was placed in threshold
            newCap = oldThr;
        else {               // zero initial threshold signifies using defaults
            newCap = DEFAULT_INITIAL_CAPACITY;
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        if (newThr == 0) {
            float ft = (float)newCap * loadFactor;
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                      (int)ft : Integer.MAX_VALUE);
        }
        //
        threshold = newThr;
     
                //新建立一个数组
            Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
        table = newTab;
        if (oldTab != null) {
            for (int j = 0; j < oldCap; ++j) {
                Node<K,V> e;
                if ((e = oldTab[j]) != null) {
                    oldTab[j] = null;
                    if (e.next == null)
                        //重新计算下标位置
                        newTab[e.hash & (newCap - 1)] = e;
                        ....省略很多代码
                        }

同时看源码可以看到定义当链表的 长度大于8的时候 会将链表转化为红黑树。
当链表的长度小于6的时候 会将红黑树转化为链表
数组默认初始容量是16（2的n次方）这样是为了位运算的方便 默认容量DEFAULT_INITIAL_CAPACITY = 2的n次方时候 DEFAULT_INITIAL_CAPACITY -1 的二进制都是1 这样我们前面说的 index的结果等同于HashCode后几位的值。
只要输入的HashCode本身分布均匀，Hash算法的结果就是均匀的。

 /**
     * The bin count threshold for using a tree rather than list for a
     * bin.  Bins are converted to trees when adding an element to a
     * bin with at least this many nodes. The value must be greater
     * than 2 and should be at least 8 to mesh with assumptions in
     * tree removal about conversion back to plain bins upon
     * shrinkage.
     *  链表转红黑树阈值
     */
    static final int TREEIFY_THRESHOLD = 8;
     /**
     * The bin count threshold for untreeifying a (split) bin during a
     * resize operation. Should be less than TREEIFY_THRESHOLD, and at
     * most 6 to mesh with shrinkage detection under removal.
     *  红黑树转成链表的 阈值
     */
    static final int UNTREEIFY_THRESHOLD = 6;
    
    /**
     * The default initial capacity - MUST be a power of two. 默认初始化容量16 必须是2的次方
     */
    static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16

接着添加操作讲解。添加操作的执行流程为:

先判断有没有初始化
再判断传入的key 是否为空，为空保存在table[o] 位置
key 不为空就对key 进hash，hash 的结果再& 数组的长度就得到存储的位置
如果存储位置为空则创建节点，不为空就说明存在冲突
解决冲突HashMap 会先遍历链表，如果有相同的value 就更新旧值，否则构建节点添加到链表头
添加还要先判断存储的节点数量是否达到阈值，到达阈值要进行扩容
扩容扩2倍，是新建数组所以要先转移节点，转移时都重新计算存储位置，可能保持不变可能为旧容量+位置。
扩容结束后新插入的元素也得再hash 一遍才能插入。
获取节点的操作和添加差不多，也是

先判断是否为空，为空就在table[0] 去找值
不为空也是先hash,&数组长度计算下标位置
再遍历找相同的key 返回值