个人对于HashMap的put方法的理解

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)
        //第一次调用put方法，resize 方法会初始化数组的长度。
        n = (tab = resize()).length;
    //判断Node<K,V> p,键值对在数组中是否已经存在，如果不存在，则把当前K,V添加到 (n - 1) & hash 这个下标的位置。
    if ((p = tab[i = (n - 1) & hash]) == null)
        tab[i] = newNode(hash, key, value, null);
    else {
        //map不为空的时候调用put方法。
        Node<K,V> e; K k;
        //p：从当前数组根据key的hash值计算出的下标取出来的 K,V键值对。
        //如果要添加的key和当前从数组中取的键值对的key相同，则将p赋给e，下面进行value的替换
        if (p.hash == hash &&
            ((k = p.key) == key || (key != null && key.equals(k))))
            e = p;
        //TreeNode:红黑树，判断 从数组取的p（K,V键值对）是否为红黑树
        else if (p instanceof TreeNode)
            e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
        else {
            //当前for是死循环，只能制动跳出当前循环,binCount:统计循环的次数。
            //TREEIFY_THRESHOLD = 8
            //treeifyBin:转为红黑树
            for (int binCount = 0; ; ++binCount) {
                //当前数组中取出的K,V键值对 对象是否存在下一个节点
                // p.next == null 的情况：数组在这个位置只存在这么一个K,V键值对，另一种情况是：当前p是一个链表，当前循环到最后一个节点，所以下一个节点为空。
                if ((e = p.next) == null) {
                    //通过上面的 if((p = tab[i = (n - 1) & hash == null])) 可知，新添加的元素key对应的下标在数组中已经存在元素了。
                    //根据 if(p.hash == hash && ((k = p.key) == key) || (key != null && key.eqquals(k))) 可知，当前要添加的元素和数组中当前下标已经存在的元素的key 不相等。
                    //所以将新添加的元素放在第一个节点或者最后一个节点的下面
                    p.next = newNode(hash, key, value, null);
                    //当前链表的长度大于8，且数组的长度大于64的时候才会将当前链表转为红黑树，否则对数组进行扩容。
                    if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                        treeifyBin(tab, hash);
                    break;
                }
                //当前 e 已经是 p的next元素了，通过当前要添加的元素和e的key进行对比，如果key相同，则跳出for循环。
                if (e.hash == hash &&
                    ((k = e.key) == key || (key != null && key.equals(k))))
                    break;
                //p = p.next。将p的下一个节点赋值给p，再去循环，再次循环的时候就 e 就 等于 是 p.next.next,p的下下一个节点。
                p = e;
            }
        }
        //当key出现重复时，e != null ，将当前出入的value赋值到当前重复的key上。
        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;
}