深度解析HashMap中的put方法及其扩容机制

        先上源码，可以看到一共分三部分，第一部分判断是否需要初始化，第二部分解决hash冲突，第三部分放入元素后判断是否需要扩容。

        那么HashMap如何解决hash冲突的呢？可以看到它的判断是i = (n - 1) & hash这一段代码，通过一个与操作来获取要放入元素在table上的一个索引，这里详细解释一下&符号的含义。我们知道&符号左右两边都相等才为true，当两边都是数字是他会先将数字转换为二进制，然后对每一位进行比较，进而得出结果。例如(n - 1) & hash左边为n-1，我们知道HashMap的初始容量为16，那么n-1的二进制值为 0000 1111，假设hash值为6，二进制为 0000 0110，那么15&6的值为 0000 0110等于6。再假设hash值为22，0001 0110，那么15&22的结果为 0000 0110，可以看到结果仍然为6，这样就起到一个取余的作用，当然仅限于n等于2的n次方的情况下。

        搞清楚了HashMap是如何找到新元素应该放在哪个位置，接下来HashMap就判断了这个位置上是否有值，如果有值它们两个的key是否相等，若相等则直接替换，若不相等的话就需要找到这个位置链表的末尾，将新元素放到链表末尾。放到末尾之后判断下链表长度是否大于等于8，若是的话就需要将链表转换为红黑树。

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)
            //如果table为null或长度为0就执行初始化操作
            n = (tab = resize()).length;
        if ((p = tab[i = (n - 1) & hash]) == null)
            //如果当前节点为空就直接放进去
            tab[i] = newNode(hash, key, value, null);
            //解决hash冲突
        else {
            Node<K,V> e; K k;
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
            //如果key相等就替换
                e = p;
            else if (p instanceof TreeNode)
            //否则如果此处是红黑树就放到末尾
                e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            else {
                //这里是个死循环，一直循环到链表末尾
                for (int binCount = 0; ; ++binCount) {
                    if ((e = p.next) == null) {
                        //下个节点为空，将k-v创建为新节点，准备放入
                        p.next = newNode(hash, key, value, null);
                        //放入前判断下此链表是否大于8，大于8就转化为红黑树
                        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;
                }
            }
            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;
    }

         下图是HashMap中TreeNode的属性，其中有一个red属性，表示是否为红节点，非红就是黑。首先红黑树规定根节点一定是黑的，叶子节点也是黑的且不存储数据，其次任何相邻两个节点不能同时为红色 ，最后，任意节点到其可到达的叶节点间包含相同数量的黑色节点。红黑树这样的特点保证了增删改查上效率的平衡。

 

    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)
            resize();
        else if ((e = tab[index = (n - 1) & hash]) != null) {
            TreeNode<K,V> hd = null, tl = null;
        //通过一个do...while循环将Node节点全部转换为TreeNode节点
            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);
        }
    }

    //将TreeNode转换为红黑树的方法
    final void treeify(Node<K,V>[] tab) {
            TreeNode<K,V> root = null;
            for (TreeNode<K,V> x = this, next; x != null; x = next) {
                next = (TreeNode<K,V>)x.next;
                x.left = x.right = null;
                if (root == null) {
                    x.parent = null;
                    x.red = false;
                    root = x;
                }
                else {
                    K k = x.key;
                    int h = x.hash;
                    Class<?> kc = null;
                    for (TreeNode<K,V> p = root;;) {
                        int dir, ph;
                        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);

                        TreeNode<K,V> xp = p;
                        if ((p = (dir <= 0) ? p.left : p.right) == null) {
                            x.parent = xp;
                            if (dir <= 0)
                                xp.left = x;
                            else
                                xp.right = x;
                            root = balanceInsertion(root, x);
                            break;
                        }
                    }
                }
            }
            moveRootToFront(tab, root);
        }