HashMap的添加元素过程以及其put方法

HashMap是双列集合中的一种，也是我们平时开发过程中常用的一种集合。本篇文章主要以源码的角度讲其添加过程以及put方法中的细节

HashMap扩容机制

Hashmap在jdk1.7以前所采用的数据结构为数组+链表的形式，而在jdk1.8以后引进了数组+链表+红黑树的结构，在同时满足数组长度大于64，链表长度大于8的时候，就会转成红黑树结构。

1.在实例化一个HashMap的时候，此时不会分配内存空间。

2.在第一次添加值的时候，HashMap的底层会创建一个初始长度为16的数组（这个量在与HashMap源码中有定义）

3.添加数据的时候，根据所存储的键的hash值计算出应存入数据的下标来确定数据所处位置，当这个位置原本没有数据的时候，则会直接将数据存入，如果原位置有值，且此时数据与原数据的hash值相等，且原本key的值本身与将要添加的key值相等，则对原值进行覆盖，并且此时的put方法返回值由null变为被此时元素的value。源码中是用这样一个表达式进行判断的

p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))

4.如果不满足这个式子，则会将此时要添加的数据“挂在”原数据的下面变成一个链表的结构，原数据的next属性将会记录此时所添加数据的地址。

5.还需要注意的一点是HashMap中有一个值来确定什么数组时候扩容，如果在构造时没有赋予该值，则会使用默认值：0.75。即当数组容量达到长度的百分之75的时候，会扩容为原来的2倍（数组刚分配空间是长度为16，当容量达到12时，会抛弃原数组，然后生成一个新的长度为32的数组，并且将原数组元素一一复制，而此时容量达到24时会继续进行扩容）。

6.而当在同时满足数组长度大于64，链表长度大于8的时候，此时链表就会转成红黑树结构。

put方法细节：

put方法就是HashMap在添加元素的时候用到的方法，也是面试中常常考察到的一点，先给大家以八股文的角度回答一下关于put方法的面试问题，这样有助于大家理解后面的源码

1.put方法在存入键值对的过程中，首先会对调用key的hashCode方法计算出key的hash值，但是这个值并不会直接存入到HashMap中，而是在put方法里调用了一个方法进行了一个这样的运算：hash=hash^(>>>16)后再存入

2.然后判断HashMap是不是刚刚初始化的，如果是，则会先为其分配内存空间，初始容量为16，扩容因子为0.75（这是jdk1.8以后的操作，jdk1.7之前在创建以后会直接分配内存）

3.接下来用此时所计算出来的hash的值来判断所存储数组的下标位置，如果该位置此时没有元素，直接添加。如果该位置此时有元素则会用key的hash值、equals、双等号判断两个结点是否相同，如果相同则覆盖，如果遍历到最后一个结点任然不相同，则将该结点放到链表的最后一个位置。

4.每次添加都会对链表长度进行判断，如果链表长度大于8，则对数组进行判断，如果此时数组长度大于64，则会将链表转换为红黑树

下面是put方法相关的源码以及解析：

// put方法解密：
    public V put(K key, V value) {
        // 直接返回putVal方法
        return putVal(hash(key), key, value, false, true);
    }
    // hash方法解密
    static final int hash(Object key) {
        int h;
        // 注意这里hash的值不是由hashCode直接计算得来的
        return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
    }
    // putVal方法解密
    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
        HashMap.Node<K,V>[] tab; HashMap.Node<K,V> p; int n, i;
        // 如果此时HashMap刚刚创建，数组容量和加载因子都为初始化，添加第一个元素的时候才会对其进行初始化
        if ((tab = table) == null || (n = tab.length) == 0)
            // resize方法是扩容方法，下面会讲到
            n = (tab = resize()).length;
        // 如果此时这个位置没有元素，则直接进行添加，在这里可以看到index的计算方式
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        // 如果有元素，则进入下面的代码块
        else {
            HashMap.Node<K,V> e; K k;
            // 判断原结点与添加结点是否相同，如果相同，新增结点的value会覆盖掉原结点的value
            if (p.hash == hash &&
                    ((k = p.key) == key || (key != null && key.equals(k))))
                e = p;
            // 判断数据结构是否为红黑树，如果新增结点是TreeNode类型的话，即数组长度大于64，链表长度大于8，则向树中添加元素
            else if (p instanceof HashMap.TreeNode)
                e = ((HashMap.TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
            // 如果原结点与新增节点不同，则进行下面的代码块
            else {
                // 对链表进行遍历
                for (int binCount = 0; ; ++binCount) {
                    // 如果此时结点为最后一个，即p.next==null，则将新增结点加入到原上一个结点的后面。
                    if ((e = p.next) == null) {
                        p.next = newNode(hash, key, value, null);
                        // 此时在这里对链表长度进行判断，如果大于8，则进入treeifBin方法内对数组长度进行判断
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            // 进去之后如果数组长度大于64，则将链表转化为红黑树
                            // 下面会对这个方法进行解释
                            treeifyBin(tab, hash);
                        break;
                    }
                    // 如果在遍历过程中，有结点与新增结点相同，则对其value进行覆盖
                    if (e.hash == hash &&
                            ((k = e.key) == key || (key != null && key.equals(k))))
                        break;
                    p = e;
                }
            }
            // 覆盖value
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        // 当代码执行到这一步之后，则说明新增结点以成功加入链表且无覆盖
        ++modCount;
        // threshold的值在resize方法中进行了初始化，为现在数组容量×扩容因子
        // 将添加过以后的数组长度与该值进行比较，若前者大，则需要扩容
        if (++size > threshold)
            resize();
        afterNodeInsertion(evict);
        return null;
    }
    // resize方法解密
    final HashMap.Node<K,V>[] resize() {
        // oldTab oldCap oldThr分别为原数组，原数组长度，原数组阈值
        HashMap.Node<K,V>[] oldTab = table;
        // 判断HashMap是否为第一次添加元素，如果是，则进行初始化
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        int oldThr = threshold;
        // newCap newThr为新数组长度，新数组阈值
        int newCap, newThr = 0;
        // 如果原数组长度大于零，即已被初始化，则
        if (oldCap > 0) {
            // 如果旧数组长度大于HashMap最大数组容量即64时
            if (oldCap >= MAXIMUM_CAPACITY) {
                // 让阈值等于Int类型的最大容量
                // 这是为下面做一个伏笔，后面会对oldTab进行判断
                //也是链表长度>8且数组长度>64之后，链表->红黑树
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            // 扩容后的新容量，如果新容量小于HashMap的的最大容量，并且旧容量大于等于初始化容量
            // 这里可以看到HashMap的扩容方式，即newCap = oldCap << 1
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                    oldCap >= DEFAULT_INITIAL_CAPACITY)
                // 这里也可以看到，扩容后的新阈值是旧阈值的2倍
                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;
        @SuppressWarnings({"rawtypes","unchecked"})
        HashMap.Node<K,V>[] newTab = (HashMap.Node<K,V>[])new HashMap.Node[newCap];
        table = newTab;
        // 如果oldTab不为null，也就是上面链表长度大于64的情况下，会返回一个oldTab
        // 接下来进行链表 -> 红黑树的操作
        if (oldTab != null) {
            for (int j = 0; j < oldCap; ++j) {
                HashMap.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 HashMap.TreeNode)
                        ((HashMap.TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                    else { // preserve order
                        HashMap.Node<K,V> loHead = null, loTail = null;
                        HashMap.Node<K,V> hiHead = null, hiTail = null;
                        HashMap.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;
    }
    // treeifyBin方法解密
    // 就是在putVal方法中，当链表长度大于8的情况下会进入这个方法内对链表长度进行判断
    final void treeifyBin(HashMap.Node<K,V>[] tab, int hash) {
        int n, index; HashMap.Node<K,V> e;
        // 如果链表长度也大于于8，则调用resize方法，也就是上面的oldTab，上面resize()方法中对是否需要转换为红黑树的一个标志
        // 即oldTab不为null，那么需要进行链表->红黑树
        if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
            // oldTab为null，则扩容就行
            resize();
        // 链表->红黑树
        else if ((e = tab[index = (n - 1) & hash]) != null) {
            HashMap.TreeNode<K,V> hd = null, tl = null;
            do {
                HashMap.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);
        }

大家可以看看上面的代码块，里面有put以及相关方法的详细解释，如有错误，欢迎指正