HashMap底层代码浅解析

我们主要看put方法，因为比较有深度。

 可以看到其中调用了putValue方法 5个参数

　　参数1 Hash(key)通过计算得到Hash散列

　　参数2 key:存储的key

　　参数3 value:存储的Value

　　参数4：代表遇到相同的key值是否替换value的值

　　参数5：不太清楚。先不管

　　

  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)  // 从这里看的出来。hashMap为懒加载，当对新的map中进行存储数据时，才会对map进行初始化,当表为空或者长度为0时，市容resizie进行初始化
            n = (tab = resize()).length;　　　　　　　　　　　　　　//将初始话后hash表的容量size的值赋值给临时变量n
        if ((p = tab[i = (n - 1) & hash]) == null)　　　　　　　　//判断要插入的桶是否存在节点，如果不存在，则直接把节点存储到该桶的head中　　
            tab[i] = newNode(hash, key, value, null);　　　　　　
        else {　　　　　　　　　　　　　　　　　　　　　　　　　　　　//如果既不是进行初始化，并且该桶中存在节点，那么就是发生的hash冲突。
            Node<K,V> e; K k;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))　　　　　　//如果添加的值与头节点相同，则将新值放入其中，只是值未变化
                e = p;
            else if (p instanceof TreeNode)　　　　　　　　　　　　　　　　　　　　　　//如果不同，并且该桶为红黑树状态，则条用putTreeVal添加。
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            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　　　　　　//当该节点到大8时，就将该桶转换为红黑树
                            treeifyBin(tab, hash);
                        break;
                    }
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))   //如果此时已有相同的节点，那么跳出循环。
                        break;
                    p = e;
                }
            }
            if (e != null) { // existing mapping for key　　　　　　　　　　//如果有重复的节点，那么需要返回旧值
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)　　　　　　//如果 onlyifAbsent为false或者旧值为null,那么将新值插入，最后返回旧值
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        ++modCount;　　　　　　　　
        if (++size > threshold)　　　　　　//当插入新节点后，判断容量如果超过阈值，则进行扩容
            resize();　　　　　　
        afterNodeInsertion(evict);　　　　　　　　//自类实现
        return null;
    }

resize（）方法   --见名知意 扩容就在这里

 final Node<K,V>[] resize() {
        Node<K,V>[] oldTab = table;　　　　　　//先获取老的tab
        int oldCap = (oldTab == null) ? 0 : oldTab.length; //判断旧表为空则旧表容量为0.
        int oldThr = threshold;　　　　　　　　　//将阈值赋值给临时变量　　　　　　　　　　
        int newCap, newThr = 0;　　　　　　
        if (oldCap > 0) {　　　　　　　　　　　　　　//判断 旧表存在
            if (oldCap >= MAXIMUM_CAPACITY) { 　　//就变存在并且容量已经到达最大，那么直接返回旧表
                threshold = Integer.MAX_VALUE;　　　　然后扩容阈值为integer的最大值、
                return oldTab;　　　　　　　　　　　　　　//直接返回tab
            }
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && 　　　　　　//新表容量是旧表容量左移一位，相当于乘2，并且小于表的最大容量，并且旧表容量大于16，那么新表的阈值，就等于旧表的二倍
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                newThr = oldThr << 1; // double threshold
        }
        else if (oldThr > 0) // initial capacity was placed in threshold　// 旧表阈值大于0，那么将旧表的阈值赋值给新表的存储容量，说明构造函数中指定了阈值
            newCap = oldThr;
        else {     　　　　          // zero initial threshold signifies using defaults　　　　　　//说明旧表不存在，则对表空间进行初始化
            newCap = DEFAULT_INITIAL_CAPACITY;　　　　　　　　　　　　// 初始化容量　　　　　　　　　　　　　　
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); //初始化阈值。阈值为容量的75%
        }
        if (newThr == 0) {　　　　　　　　　　//新的阈值为0，则使用新表空间的容量乘增长因子。%75，得到新的阈值
            float ft = (float)newCap * loadFactor;　　　　　　　　　　
            newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
                      (int)ft : Integer.MAX_VALUE);
        }　　
        threshold = newThr;　　　　　　　　//将临时变量赋值给阈值
        @SuppressWarnings({"rawtypes","unchecked"})　　　　　　//
            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;　　　　　　　　　　　　//声明一个Node
                if ((e = oldTab[j]) != null) { //旧表中元素若不为bull,则赋值为null,方便gc
                    oldTab[j] = null;　　　　　
                    if (e.next == null)　　　　　　//如果节点只有一个元素，将旧表节点赋值给新表节点
                        newTab[e.hash & (newCap - 1)] = e;　　　
                    else if (e instanceof TreeNode)　　　　　　//如果e节点为红黑树
                        ((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;　　　　　　　　　　　　　　将节点值赋值给next


                            if ((e.hash & oldCap) == 0) {　　　　　　//对该节点hash并与旧表容量做与运算，如果为0，则
                                if (loTail == null)　　　　　　　　　　//判断低位节点尾部是否为null,如果为null，则将节点赋值到低位节点的head中
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　
                                    loHead = e;
                                else
                                    loTail.next = e;　　　　　　　　　　//如果低位节点尾部不为null,则将该节点赋值到低位节点尾部的下一个元素中
                                loTail = e;
                            }
                            else {　　　　　　　　　　　　　　　　　　　　//不为0
                                if (hiTail == null)　　　　　　　　　　//判断高位节点是否为null.
                                    hiHead = e;　　　　　　　　//为null则将该节点赋值给高位节点，
                                else
                                    hiTail.next = e;　　　　　　//在高位节点尾部链接上该节点
                                hiTail = e;
                            }
                        } while ((e = next) != null);　　　　　　//直到该链表为节点为空
                        if (loTail != null) {　　　　　　　　//如果低位节点尾部不为bull
                            loTail.next = null;　　//将低位节点的尾部的下一个元素清空为null
                            newTab[j] = loHead;　　　　　　　　//将低位节点的头部，赋值到新表的一个桶中，
                        }
                        if (hiTail != null) {　　　　　　　　//高位节点不为null
                            hiTail.next = null;　　　　　　//将高位节点的尾部下一个值清空为null。
                            newTab[j + oldCap] = hiHead;　　　　　　将高位节点的头部，赋值给新表中高位桶中。
                        }
                    }
                }
            }
        }
        return newTab;
    }

如果表中节点已成为红黑树，那么直接在红黑数中进行赋值操作

   final void split(HashMap<K,V> map, Node<K,V>[] tab, int index, int bit) {
　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　//参数1 map ，参数2位新表，参数3为，节点所在的索引，参数4位旧表容量
            TreeNode<K,V> b = this;　　　　　　　　　　　　　　　　　　　　　//头结点e　　　　　　　　　
            // Relink into lo and hi lists, preserving order　　　　　　　　　　　//与链表reHash中相同，将红黑树分为两个部分　　　　　
            TreeNode<K,V> loHead = null, loTail = null;
            TreeNode<K,V> hiHead = null, hiTail = null;
            int lc = 0, hc = 0;
            for (TreeNode<K,V> e = b, next; e != null; e = next) {　　　　　　　　　　遍历红黑树
                next = (TreeNode<K,V>)e.next;　　　　　　　　　　　　　　　　　　//将e链的下个值赋值给next
                e.next = null;　　　　　　　　　　　　　　　　　　　　　　　　　　//将e链的下下个节点设为空
                if ((e.hash & bit) == 0) {　　　　　　　　　　　　　　　　　　//用e及诶按的的hash对旧有容量计算，如果为0
                    if ((e.prev = loTail) == null)　　　　　　//判断低位链表尾部是否为null
                        loHead = e;　　　　　　　　　　　　　　　　//为空，则将e节点赋值给低位节点的头节点
                    else
                        loTail.next = e;　　　　　　　　　　//否则赋值给低位节点尾部节点的下一个节点
                    loTail = e;　　　　　　　　
                    ++lc;　　　　　　　　　　　　　　　　　　//低位节点长度加一
                }
                else {
                    if ((e.prev = hiTail) == null)　　　　　　　　//同理
                        hiHead = e;
                    else
                        hiTail.next = e;
                    hiTail = e;
                    ++hc;
                }
            }

            if (loHead != null) {
                if (lc <= UNTREEIFY_THRESHOLD)　　　　　　　　　　//低位节点长度不大于6则将该map转换为红海曙
                    tab[index] = loHead.untreeify(map);
                else {　　　　　　　　　　
                    tab[index] = loHead;　　　　　　　　　　　　//否则将该低位节点的头结点赋值给新表在该索引处的位置
                    if (hiHead != null) // (else is already treeified)　　　　//如果高位节点的头节点不为null,则将该低位链表转换为红黑树
                        loHead.treeify(tab);　　　　　　//
                }
            }
            if (hiHead != null) {
                if (hc <= UNTREEIFY_THRESHOLD)
                    tab[index + bit] = hiHead.untreeify(map);　　　　　　高位链表类似
                else {
                    tab[index + bit] = hiHead;
                    if (loHead != null)
                        hiHead.treeify(tab);
                }
            }
        }
　　　　　　如果当map容量扩大，那么reHash时，可能会有红黑树，转换为链表，此处分为高低两个链接，进程节点为存储。

将链表结构 ，转换成红黑树

 final void treeifyBin(Node<K,V>[] tab, int hash) {　　　　//
        int n, index; Node<K,V> e;
        if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)　　　　//如果表为null,或者表的长度不足64，直接进行hash扩容
            resize();
        else if ((e = tab[index = (n - 1) & hash]) != null) {　　//判断该节点存在数据
            TreeNode<K,V> hd = null, tl = null;
            do {
　　　　　　　　　　//将node转换成treeNode
                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);
        }
    }

参考：https://blog.csdn.net/qq_19431333/article/details/55505675