JDK1.8 HashMap putValue源码解析

今天主要和大家一起看一下JDK1.8里面HashMap类的putValue的原理。
分析能力有限，有错误欢迎指出。 废话不多说开始把！

今天要分析的就是这个方法

 final V putVal(int hash, K key, V value, boolean onlyIfAbsent,                   boolean evict) 

首先看一下源码

    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)        //这里的resize  是初始化的时候调用 后面会讲            n = (tab = resize()).length;    //重新计算一下大小    //获取要插入元素在 哈希桶中的位置    if ((p = tab[i = (n - 1) & hash]) == null) //如果这个位置没有Node        //   return new Node<>(hash, key, value, next);        tab[i] = newNode(hash, key, value, null);   //直接创建一个新的Node        else {  //原来这个桶的位置上有Node            Node<K,V> e; K k;            if (p.hash == hash &&                ((k = p.key) == key || (key != null && key.equals(k)))) //如果你和桶上的第一个Node相等                e = p;  //直接覆盖值            else if (p instanceof TreeNode)//如果 你定位到的元素是一个TreeNode(Node的一个子类，也是HashMap的一个内部类)                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);//那么就插入一TreeNode节点            else {//定位到这个hash桶了 但是这里面是链表（没有进行过树化）                for (int binCount = 0; ; ++binCount) {//是链表                    if ((e = p.next) == null) {                    //如果p节点的next为空 直接在后面插入                        p.next = newNode(hash, key, value, null);    //这里的树化是putValue的时候 如果本来是链表 而且长度超过了8 那么就进行树化                         if (binCount >= TREEIFY_THRESHOLD - 1)                     //** 这个方法一会来分析                            treeifyBin(tab, hash);                        break;                }//如果下一个节点e 不为null 并且这个链表中的节点就是你要找的节点 终止循环                                   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)                    e.value = value;    //将新的值赋值                afterNodeAccess(e); //这个是空实现                return oldValue;            }        }            ++modCount;// 修改次数+1 和fastRemove()有关也和并发修改有关        if (++size > threshold) //如果大于了阙值 需要扩容的大小            resize();   //重新设置hash桶的大小，也有可能进行树化，见后面代码        afterNodeInsertion(evict);//空方法        return null;    }

有三个方法需要跟进去看看

1. resize()

 final Node<K,V>[] resize() {        Node<K,V>[] oldTab = table; // oldTable:当前的表        int oldCap = (oldTab == null) ? 0 : oldTab.length;  //如果你是新创建的话 表的大小就是0 否则就是原来的大小        //第一次是为0的    代表 static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16        int oldThr = threshold;             int newCap, newThr = 0; //新的容量和新的扩容        //如果旧的容量大于0        if (oldCap > 0) {        //如果旧的容量大于最大的容量            if (oldCap >= MAXIMUM_CAPACITY) {               //那么扩容大小 = 最大范围                threshold = Integer.MAX_VALUE;              //直接返回了                return oldTab;              }        //否则 如果新的大小等于 oldCap * 2 < 最大的容量 ， 并且旧的容量大于默认的初始化大小16            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&                     oldCap >= DEFAULT_INITIAL_CAPACITY)     // double threshold  新的扩容 = 旧的扩容 * 2                 newThr = oldThr << 1;        }        else if (oldThr > 0) // initial capacity was placed in threshold             newCap = oldThr;    //如果旧的扩容本来就大于0，那么新的容量就是旧的扩容        else {               // zero initial threshold signifies using defaults 说明是 threshold为0的时候的情况            newCap = DEFAULT_INITIAL_CAPACITY;      //新的容量为默认容器的容量            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); //新的阙值为 默认的容量 * 负载因子        }           if (newThr == 0) {  //如果新的扩容为0             float ft = (float)newCap * loadFactor;  //计算得到新的阙值        //新的阙值 =  如果新的容量小于 最大的容量 并且 新的阙只 < 最大的容量 那么新的阙值 = 计算的 否则 = 最大int            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) {    //遍历旧的hash桶        for (int j = 0; j < oldCap; ++j) {                  Node<K,V> e;                    if ((e = oldTab[j]) != null) {//如果旧的hash桶的元素不为null  e为旧的hash桶的元素                    oldTab[j] = null;   //旧的hash桶设置为null                    if (e.next == null)     //如果你就是一个元素                        newTab[e.hash & (newCap - 1)] = e;  //那么在新的hash桶给你安排一个位置  位置是你的hash值 & 新的桶的容量-1 这相当于 你的hash值 与 你的容量进行取模运算                    else if (e instanceof TreeNode) //如果你不只一个元素并且是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;    }

2.final void split(HashMap< K,V > map, Node< K,V >[] tab, int index, int bit)

上述方法在resize()过程中被调用
//被调用的代码 split(当前hash表，新的哈希桶，要分割的元素的小标，旧的容量)
((TreeNode

 final void split(HashMap<K,V> map, Node<K,V>[] tab, int index, int bit) {            TreeNode<K,V> b = this; //这里的this :    e = oldTab[j] 上下文中的代码            // Relink into lo and hi lists, preserving order            TreeNode<K,V> loHead = null, loTail = null; //低位的头和低位的尾            TreeNode<K,V> hiHead = null, hiTail = null; //高位的头和高位的尾            int lc = 0, hc = 0; //地位和高位的2个计数器            for (TreeNode<K,V> e = b, next; e != null; e = next) {                next = (TreeNode<K,V>)e.next;   //获取下一个节点                e.next = null;  //设置为null                if ((e.hash & bit) == 0) {  //如果 e.hash 与 原来旧的容量 & 为 0 说明不需要进行移动位置      (e.hash & (bit-1) ) <==> e.hash % bit , e.hash & bit 计算的就是新增出来的那一位 如果结果为0 说明不需要进行位移                    if ((e.prev = loTail) == null)  //如果低位的尾巴为null                        loHead = e;     //将e 复制给头                    else                        loTail.next = e;    //如果尾巴不为null 尾巴的next 为 e                    loTail = e;     //将e 作为新的尾巴                    ++lc;   //次数 + 1                 }                else {                    if ((e.prev = hiTail) == null)  //否则需要移动位置                          hiHead = e;     //高位的链表和低位一样                    else                        hiTail.next = e;                    hiTail = e;                    ++hc;                }            }            if (loHead != null) {   //如果有链表                if (lc <= UNTREEIFY_THRESHOLD)  //如果长度 <= 6                      tab[index] = loHead.untreeify(map);//取消树化 将这个树里面的链表结构变成普通的链表结构                else {                    tab[index] = loHead;    //否则将地位复制给原来的下标                    if (hiHead != null) // (else is already treeified)                        loHead.treeify(tab);    //进行树化                }            }            if (hiHead != null) {                if (hc <= UNTREEIFY_THRESHOLD)  hc < = 6;取消树化                    tab[index + bit] = hiHead.untreeify(map);//进行了移位 位置偏移 下标 + 原来的容器大小                else {                    tab[index + bit] = hiHead;                    if (loHead != null)                        hiHead.treeify(tab);                }            }        }

这里面设计到2个方法在resize中 如果链表的长度 <= UNTREEIFY_THRESHOLD
就进行非树化，否则就进行树化。这里的非树化就是将TreeNode转换成Node

  final Node<K,V> untreeify(HashMap<K,V> map) {            Node<K,V> hd = null, tl = null;            for (Node<K,V> q = this; q != null; q = q.next) {   //将q转换成普通的Nod return new Node<>(p.hash, p.key, p.value, next);                Node<K,V> p = map.replacementNode(q, null);                if (tl == null)                     hd = p; //头为p                else                    tl.next = p;                    tl = p;                 }            return hd;//返回这个链表        }

树化为相反的过程

 /**     * Forms tree of the nodes linked from this node.     * @return root of tree     */

下面的这个方法也在hashMap中的putVal方法中的 treeifyBin(tab, hash);被调用
如果当时插入元素在hash桶为普通链表的情况下并且链表的长度大于8 就进行树化

  final void treeify(Node<K,V>[] tab) {            TreeNode<K,V> root = null;    //初始化x 就是这个节点        for (TreeNode<K,V> x = this, next; x != null; x = next) {                   next = (TreeNode<K,V>)x.next; //获取x的下一个节点                x.left = x.right = null;    //设置x的左右为null                if (root == null) {                    x.parent = null;                        x.red = false;  //根节点为黑色                    root = x;   //根节点为x                 }                else {  //根节点不为null                    K k = x.key;    //  获取K key                    int h = x.hash; //获取hash                    Class<?> kc = null; //获取数据的类型                    //开始循环构建 将根节点复制给p            for (TreeNode<K,V> p = root;;) {            int dir, ph; //ph 当前节点的hash值                    // dir 判断左右用的                        K pk = p.key;                        if ((ph = p.hash) > h)                             dir = -1;                        else if (ph < h)                            dir = 1;                        else if ((kc == null &&                                  (kc = comparableClassFor(k)) == null) ||                                 (dir = compareComparables(kc, k, pk)) == 0)                            dir = tieBreakOrder(k, pk); //当 hashCode相等 并且没有比较器的时候 进行另外的一种方式比较 可以看一下源码                        TreeNode<K,V> xp = p;                         if ((p = (dir <= 0) ? p.left : p.right) == null) {  //如果p节点的左儿子或者右儿子为null 那么就开始创建 否则就继续往下面找            //通过大小比较 判断 如果新的p（原来p的子节点） 为null                            x.parent = xp;  //x.parent就是当前的p                             if (dir <= 0)                                   xp.left = x;                             else                                xp.right = x;                            root = balanceInsertion(root, x);//红黑树的插入 把新的节点插入到当前树中 新的节点的parent就是你当前遍历的节点 而且当前遍历的节点的左儿子/右儿子已经确定                            break;                        }                    }                }            }            moveRootToFront(tab, root);        }    //红黑树的插入     static <K,V> TreeNode<K,V> balanceInsertion(TreeNode<K,V> root,                                                    TreeNode<K,V> x) {            x.red = true;   //将要插入的节点设置为红色        //修正树            for (TreeNode<K,V> xp, xpp, xppl, xppr;;) {       // xp 为 要插入节点的爸爸       // xpp 为要插入节点的爷爷       // xppl 要插入节点的爷爷的左孩子       // xppr 要插入节点的爷爷的右孩子                 if ((xp = x.parent) == null) {  //如果他的爸爸为null                    x.red = false;      //就将他设置为黑色                     return x;   //直接返回  根节点                }                else if (!xp.red || (xpp = xp.parent) == null)  //如果 爸爸是黑色 不影响红黑树的性质  //或者他是红色 并且他的爷爷为空 说明他爸爸就是根  也直接返回 符合性质 黑色下面是2个红色                    return root;    //那么直接返回root                if (xp == (xppl = xpp.left)) {  //如果爸爸(红色) 是爷爷的左儿子                    if ((xppr = xpp.right) != null && xppr.red) {  //叔叔节点不为空并且是红色                        xppr.red = false;   //叔叔变成黑色                        xp.red = false;     //爸爸变成黑色                        xpp.red = true;     //爷爷变成红色                        x = xpp;        //当前节点指向爷爷节点                    }                    else {  //叔叔为null 或者 叔叔为黑色（若存在）                        if (x == xp.right) {    //如果你是爸爸的右孩子 并且叔叔是黑色                            root = rotateLeft(root, x = xp);    //将父节点作为当前节点    //新的当前节点进行左旋                            xpp = (xp = x.parent) == null ? null : xp.parent;       // xp 为旋转后的当前节点的父亲                                            // xpp 如果xp都为空了 那么xpp 也为空 否则 xpp = xp.parent                        }                        if (xp != null) {                            xp.red = false; //将父节点设置为黑色                            if (xpp != null) {                                xpp.red = true; //将祖父节点设置为红色                                root = rotateRight(root, xpp);  //对祖父节点进行右旋                            }                        }                    }                }                else {  //这里为父亲为右孩子的情况与左边类似 不在复述                    if (xppl != null && xppl.red) {                         xppl.red = false;                           xp.red = false;                             xpp.red = true;                             x = xpp;                            }                    else {                        if (x == xp.left) {                             root = rotateRight(root, x = xp);   //对你爸爸进行右旋                            xpp = (xp = x.parent) == null ? null : xp.parent;                        }                        if (xp != null) {                            xp.red = false;                            if (xpp != null) {                                xpp.red = true;                                root = rotateLeft(root, xpp);                            }                        }                    }                }            }        }

3. moveRootToFront(tab, root);
/**
* Ensures that the given root is the first node of its bin.
*/

          static <K,V> void moveRootToFront(Node<K,V>[] tab, TreeNode<K,V> root) {        int n;        if (root != null && tab != null && (n = tab.length) > 0) {//如果根存在            int index = (n - 1) & root.hash;    //获取根在的hash桶的下标            TreeNode<K,V> first = (TreeNode<K,V>)tab[index];    //获取对应的节点            if (root != first) {    //如果根不是第一个                Node<K,V> rn;   // rootnext                tab[index] = root;  //将根设置为第一个                TreeNode<K,V> rp = root.prev;   //rootprev 根的前面一个                if ((rn = root.next) != null)   //如果根的next 不为null                    ((TreeNode<K,V>)rn).prev = rp;  // root.next的prev = root.prev                if (rp != null) //如果root.prev不为null                    rp.next = rn;   //root.prev的下一个 = root.next                if (first != null)   //如果first第一个不为null                    first.prev = root;  第一个的前面为root                root.next = first;  //跟的后面为原来的第一个        root.prev = null; //根的前面为null            }            assert checkInvariants(root);        }    }