HashMap核心方法：put()、putVal()、resize()与treeifyBin()

一、put方法

put方法的源码如下：

由此可见put的核心方法为putVal()
putVal方法各参数值讲解：

前面三个参数不做过多讲解，第4个参数是控制是否要覆盖原来key中已经存在的值，比如HashMap的putIfAbsent方法调的也是putVal方法，它的第4个参数传的值为true,因此putIfAbsent方法不会覆盖原有的值。

二、putVal方法

putVal方法的源码解析如下：

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        // 如果数组为空，进行 resize() 初始化
        if ((tab = table) == null || (n = tab.length) == 0)
            n = (tab = resize()).length;
        // (n - 1) & hash相当于取模，获取数组的索引位置
        // 如果计算的位置上Node不存在，直接创建节点插入
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            // 如果计算的位置上Node 存在，链表或者红黑树处理
            Node<K,V> e; K k;
            // 如果已存在的key和传入的key一模一样，则需要覆盖
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            // 如果 index 位置元素已经存在，且是红黑树
            else if (p instanceof TreeNode)
                // 将元素put到红黑树中
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                // 否则如果是链表的情况，对链表进行遍历，并统计链表长度
                for (int binCount = 0; ; ++binCount) {
                    // 如果节点链表的next为空
                    if ((e = p.next) == null) {
                        // 找到节点链表中next为空的节点，创建新的节点插入
                        p.next = newNode(hash, key, value, null);
                        // 如果节点链表中数量超过TREEIFY_THRESHOLD（8）个，转化为红黑树
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            // 树化
                            treeifyBin(tab, hash);
                        break;
                    }
                    // 判断节点链表中的key和传入的key是否一样
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        // 如果一样的话，退出
                        break;
                    p = e;
                }
            }
            // 如果存在相同key的节点e不为空
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                // onlyIfAbsent 表示是否仅在 oldValue 为 null 的情况下更新键值对的值
                if (!onlyIfAbsent || oldValue == null)
                    // 设置新的值
                    e.value = value;
                afterNodeAccess(e);
                // 返回旧的结果
                return oldValue;
            }
        }
        ++modCount;
        // 当前大小大于临界大小，扩容
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
}

2.1、补充点

1. put方法第5个参数evict在hashMap中并没有实际意义，只有在子类方法中才会使用到。
   put方法第5个参数evict只调用了afterNodeInsertion(evict)，而afterNodeInsertion(evict)是一个空方法，如下图所示。
   
2. (n - 1) & hash
   (n - 1) & hash相当于取模，但与计算比取模的效率要高。
   

三、resize方法

resize方法是一个扩容的方法，同时也是一个初始化HashMap的方法。
resize方法的源码解析如下：

final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;
        // 现有容量的大小，等于数组的长度，如果数组为空，返回0
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        // 现有的扩容阈值
        int oldThr = threshold;
        // newCap表示新的容量，newThr新的扩容阈值
        int newCap, newThr = 0;
        // 如果现有容量大于0，表示已经初始化过了
        if (oldCap > 0) {
            // 如果现有容量已经大于最大容量。结束扩容，直接返回
            if (oldCap >= MAXIMUM_CAPACITY) {
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
             // 否则，如果扩大两倍之后的容量小于最大容量，且现有容量大于等于初始容量16    
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                 // 新的扩容阀值扩大为两倍，左移<<1 相当于乘以2
                newThr = oldThr << 1; // double threshold
        }
        // 否则如果当前容量等于0 ，但是当前扩容阈值 > 0,调用有参构造函数会到这里
        else if (oldThr > 0) // initial capacity was placed in threshold
             // 进入这里，新的容量等于当前的扩容阈值，
            newCap = oldThr;
        // 否则如果当前容量等于0,并且挡墙扩容阈值=0，调用无参构造函数进入这里
        else {               
            // 新的容量等于默认容量
            newCap = DEFAULT_INITIAL_CAPACITY;
            // 新的扩容阈值等于默认负载因子0.75*默认容量16=12
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        // 如果新的扩容阈值等于0
        if (newThr == 0) {
            // 设置新的扩容阈值等于新的容量*负载因子
            float ft = (float)newCap * loadFactor;
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                      (int)ft : Integer.MAX_VALUE);
        }
       // 设置hashmap对象的扩容阈值位新的扩容阈值
        threshold = newThr;
        @SuppressWarnings({"rawtypes","unchecked"})
        // 初始化数组     
        Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
        // 设置hashmap对象的桶数组为newTab
        table = newTab;
        // 下面时rehash的过程
         // 如果旧的桶数组不为空，则遍历桶数组，并将键值对映射到新的桶数组中
        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;
                    // 如果节点是红黑树    
                    else if (e instanceof TreeNode)
                        // 需要对红黑树进行拆分
                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                    // 如果节点是链表 
                    else { // preserve order
                        Node<K,V> loHead = null, loTail = null;
                        Node<K,V> hiHead = null, hiTail = null;
                        Node<K,V> next;
                         // 遍历链表，并将链表节点按原顺序根据高低位分组
                        do {
                            next = e.next;
                            if ((e.hash & oldCap) == 0) {
                                if (loTail == null)
                                    loHead = e;
                                else
                                    loTail.next = e;
                                loTail = e;
                            }
                            else {
                                if (hiTail == null)
                                    hiHead = e;
                                else
                                    hiTail.next = e;
                                hiTail = e;
                            }
                        } while ((e = next) != null);
                         // 将分组后的链表映射到新桶中
                        if (loTail != null) {
                            loTail.next = null;
                            newTab[j] = loHead;
                        }
                        if (hiTail != null) {
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
        return newTab;
}

3.1、补充点

1. 扩容后链表的处理方法：
   
   
2. 扩容后红黑树的处理方法：
   红黑树的拆分也是分低位和高位的。如果拆分后节点大于6个，则还是红黑树、如果节点数小于6个，则要退化成链表。

四、treeifyBin方法

treeifyBin方法将普通节点链表转换成树形节点。

扩容树化要满足两个条件：

1. 链表长度大于等于 8
2. 桶数组容量大于等于64

treeifyBin方法的源码解析如下：

final void treeifyBin(Node<K,V>[] tab, int hash) {
        int n, index; Node<K,V> e;
        // 桶数组容量小于 MIN_TREEIFY_CAPACITY，优先进行扩容而不是树化
        if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
            resize();
        else if ((e = tab[index = (n - 1) & hash]) != null) {
            // hd 为头节点（head），tl 为尾节点（tail）
            TreeNode<K,V> hd = null, tl = null;
            do {
                // 将普通节点替换成树形节点
                TreeNode<K,V> p = replacementTreeNode(e, null);
                if (tl == null)
                    hd = p;
                else {
                    p.prev = tl;
                    tl.next = p;
                }
                tl = p;
            } while ((e = e.next) != null);
            // 将普通链表转成由树形节点
            if ((tab[index] = hd) != null)
                // 将树形链表转换成红黑树
                hd.treeify(tab);
        }
    }