jdk1.8版本，HashMap源码学习（2）——put,putVal,resize

put

put方法

    /**
     * Associates the specified value with the specified key in this map.
     * If the map previously contained a mapping for the key, the old
     * value is replaced.
     *
     * @param key key with which the specified value is to be associated
     * @param value value to be associated with the specified key
     * @return the previous value associated with <tt>key</tt>, or
     *         <tt>null</tt> if there was no mapping for <tt>key</tt>.
     *         (A <tt>null</tt> return can also indicate that the map
     *         previously associated <tt>null</tt> with <tt>key</tt>.)
     */
    public V put(K key, V value) {
       return putVal(hash(key), key, value, false, true);
    }
    

putVal

/**
     * Implements Map.put and related methods
     *
     * @param hash hash for key key的hash值，会重复
     * @param key the key
     * @param value the value to put
     * @param onlyIfAbsent if true, don't change existing value  为true当put时不会替换key对应的值（如果不存在还是添加）
     * @param evict if false, the table is in creation mode.
     * @return previous value, or null if none
     */
    final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
                   boolean evict) {
         //tab一个节点数组，保存节点
        Node<K,V>[] tab; Node<K,V> p; int n, i;
        if ((tab = table) == null || (n = tab.length) == 0)
        //第一次new Hash Map后，put时，会进行扩容，具体扩容默认值或者初始化设置的相关值（比如初始设置10，则扩容2^4=16。比如设置15，还是2^4=16）
            n = (tab = resize()).length;
            
         
        if ((p = tab[i = (n - 1) & hash]) == null)
            //当前（数组长度-1）&hash后作为index，一个新的节点保存在index的位置
            tab[i] = newNode(hash, key, value, null);
        else {
            //如果在数组tab中的index位置存在元素了
            //e保存这个存在的节点
            Node<K,V> e; K k;
            //if中给这个存在的节点赋值了
            if (p.hash == hash &&
                ((k = p.key) == key || (key != null && key.equals(k))))
                //if中比较当前元素hash相同，key相同，保存这个节点，在后面把值替换掉
                e = p;
            else if (p instanceof TreeNode)
             	//hashmap保存数据，按照数组+链表+红黑树的形式
            	//如果这个节点是一个红黑树，那就是把新加的节点放到树中
                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
                        	//如果大于等于8，就要尝试去把当前链表构成红黑树
                        	//尝试中判断当前链表大小是不是大于等于64，如果是才会构成红黑树
                            treeifyBin(tab, hash);
                        break;
                    }
                    //这里，链表对应 于在tab中保存的下标是相同的即（tab数组大小-1）&hash相同
                    //同时判断key是否相同。
                    if (e.hash == hash &&
                        ((k = e.key) == key || (key != null && key.equals(k))))
                        //如果新节点和当前链表中的某个节点匹配，break。这时候e保存的就是这个存在的节点
                        break;
                    p = e;
                }
            }
            //e保存存在的节点，如果为空标识hashmap中不存在节点，已经新加进去了
            //如果不为空，就会去判断onlyIfAbsent （是不是替换旧的value值），从而进行替换value
            //然后返回旧的value。代码中调用的afterNodeAccess(e);就是一个空方法，在hashmap中没什么用，我认为。
            if (e != null) { // existing mapping for key
                V oldValue = e.value;
                if (!onlyIfAbsent || oldValue == null)
                    e.value = value;
                afterNodeAccess(e);
                return oldValue;
            }
        }
        //新增的时候修改次数增加，通arraylist相同，
        ++modCount;
        //大小是否超出阈值，超出就会扩容。这里的size就是我们hashmap的size()得到的值
        if (++size > threshold)
            resize();
         //空方法
        afterNodeInsertion(evict);
        return null;
    }

resize

 final Node<K,V>[] resize() {
 		//扩容时，保存老的节点数组，
        Node<K,V>[] oldTab = table;
        //老的容量
        int oldCap = (oldTab == null) ? 0 : oldTab.length;
        //老的阈值（临界值），当hashmap大小大于这个阈值时会进行扩容
        int oldThr = threshold;
        //新的容量阈值
        int newCap, newThr = 0;
        //如果扩容前容量大于0，说名不是第一次扩容
        if (oldCap > 0) {
        	//判断大小是不是超除hashmap的最大范围1 << 30，就是2^30
            if (oldCap >= MAXIMUM_CAPACITY) {
                threshold = Integer.MAX_VALUE;
                return oldTab;
            }
            //大小在最大值和最小值之间，就是新的容量扩大2倍，新的临界值扩大两倍。不然就只让大小扩大两倍
            else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY)
                newThr = oldThr << 1; // double threshold
        }
        //如果老的阈值大于0，一般是由于第一次new时传递了初始容量，计算了这个值得。
        else if (oldThr > 0) // initial capacity was placed in threshold
        	//oldThr为第一次初始化时设置得容量，计算得出得值和初始容量得设置有关
            newCap = oldThr;
         //通过new HashMap()初始化时，才会来下面的代码，就是默认值，大小16，临界值0.75*16
        else {               // zero initial threshold signifies using defaults
            newCap = DEFAULT_INITIAL_CAPACITY;
            newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
        }
        if (newThr == 0) {
        	//新的临界值为0时重新计算，就是容量*加载因子
        	//出现的情况1：当最开始设置容量4，第一次扩容时容量设置为oldThr（初始化时计算得出）。同时调用下面代码设置临界值
        	//出现情况2：当情况1再次重4扩容到8，调用上面ifelse时候存在情况（newCap < MAXIMUM_CAPACITY &&
                     oldCap >= DEFAULT_INITIAL_CAPACITY）不满足时没有设置newThr，调用下面设置newThr
            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) {
            	//保存老table中的的节点
                Node<K,V> e;
                //如果不为空就会进行重新分配，当然啦
                if ((e = oldTab[j]) != null) {
                    oldTab[j] = null;
                    //如果老节点的next没有，就标识这只是一个节点嘛，不是树和链表，直接设置到新的数组中
                    if (e.next == null)
                        newTab[e.hash & (newCap - 1)] = e;
                    //发现老的节点是红黑树
                    else if (e instanceof TreeNode)
                    	//有点复杂啊
                        ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
                     //发现老的节点不是树，就是个链表。下面的代码有点厉害，实在有问题参考网上的吧，我也是看过网上的理解
                     //总体的意思是：把链表分成两个链表分别放到新数组中的两个位置，这样这个节点的数组就转移到新数组中去了
                     //怎么分的？我们知道，在原本的这个链表上hash&（oldCap-1）是相同的
                     //在新的数组下也要保证一条链表上的hash&（newCap-1）相同
                     //我们newCap是oldCap左移一位的产物
                     //比如oldCap-1：    111111  这里1000000不就是oldCap-1+1，就是oldCap的长度嘛
                     //则就newCap-1：1111111
                     //当我hash&这个值时，前面的几位都时相同的，无非就是newCap-1这边最右边多了一位，要么0，要么1
                     //是0的时候就是和原本hash&(oldCap-1)放在相同位置，是1的时候就是长度多了一个oldCap，原本的位置+oldCap就是放到新数组的位置
                     //使用hash&oldCap其实就是去看最高位到底是0还是1.也可以使用newCap-1 & hash查看最高位是0还是1
                     //oldCap相差newCap-1就是右边除最高位的全部。他们两个得出的最高位到底是1，还是0是一样的结果
                    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;
                            //最高位0，形成一个链表
                            if ((e.hash & oldCap) == 0) {
                                if (loTail == null)
                                    loHead = e;
                                else
                                    loTail.next = e;
                                loTail = e;
                            }//最高位1，形成一个链表
                            else {
                                if (hiTail == null)
                                    hiHead = e;
                                else
                                    hiTail.next = e;
                                hiTail = e;
                            }
                        } while ((e = next) != null);
                        if (loTail != null) {//最高位0的放到原位置
                            loTail.next = null;
                            newTab[j] = loHead;
                        }
                        if (hiTail != null) {//最高位1的放到oldCap+原位置
                            hiTail.next = null;
                            newTab[j + oldCap] = hiHead;
                        }
                    }
                }
            }
        }
        return newTab;
    }