Jav8 HashMap-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;

        // 如果存储元素的table为空，则进行必要字段的初始化

        if ((tab = table) == null || (n = tab.length) == 0)

            n = (tab = resize()).length;    // 获取长度（16）

        // 如果根据hash值获取的结点为空，则新建一个结点

        if ((p = tab[i = (n - 1) & hash]) == null)      // 此处 & 代替了 % （除法散列法进行散列）

            tab[i] = newNode(hash, key, value, null);

        // 这里的p结点是根据hash值算出来对应在数组中的元素

        else {

            Node<K,V> e; K k;

            // 如果新插入的结点和table中p结点的hash值，key值相同的话

            if (p.hash == hash &&

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

                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) {

                        p.next = newNode(hash, key, value, null);

                        // 链表长度大于8时，将链表转红黑树

                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st

                            treeifyBin(tab, hash);

                        break;

                    }

                    if (e.hash == hash &&

                        ((k = e.key) == key || (key != null && key.equals(k))))

                        break;

                    // 及时更新p

                    p = e;

                }

            }

            // 如果存在这个映射就覆盖

            if (e != null) { // existing mapping for key

                V oldValue = e.value;

                // 判断是否允许覆盖，并且value是否为空

                if (!onlyIfAbsent || oldValue == null)

                    e.value = value;

                afterNodeAccess(e);     // 回调以允许LinkedHashMap后置操作

                return oldValue;

            }

        }

        ++modCount;     // 更改操作次数

        if (++size > threshold)     // 大于临界值

            // 将数组大小设置为原来的2倍，并将原先的数组中的元素放到新数组中

            // 因为有链表，红黑树之类，因此还要调整他们

            resize();  

        // 回调以允许LinkedHashMap后置操作

        afterNodeInsertion(evict);

        return null;

    }

resize() 解析：

//初始化或者扩容之后元素调整

final Node<K,V>[] resize() {

        // 获取旧元素数组的各种信息

        Node<K,V>[] oldTab = table;

        // 长度     

        int oldCap = (oldTab == null) ? 0 : oldTab.length;

        // 扩容的临界值

        int oldThr = threshold;

        // 定义新数组的长度及扩容的临界值

        int newCap, newThr = 0;

        if (oldCap > 0) {   // 如果原table不为空

            // 如果数组长度达到最大值，则修改临界值为Integer.MAX_VALUE

            if (oldCap >= MAXIMUM_CAPACITY) {

                threshold = Integer.MAX_VALUE;

                return oldTab;

            }

            // 下面就是扩容操作（2倍）

            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&

                     oldCap >= DEFAULT_INITIAL_CAPACITY)

                // threshold也变为二倍

                newThr = oldThr << 1;

        }

        else if (oldThr > 0) // initial capacity was placed in threshold