HashMap(jdk1.8)

HashMap(jdk1.8):

hash桶：在开链法中，每条链表叫hash桶。

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16 初始容量是16

static final float DEFAULT_LOAD_FACTOR = 0.75f; //默认负载因子 等于0.75是一个时间和空间复杂度的一个平衡，更大的话可能节约更多空间，但会导致get和put的效率降低。

static final int TREEIFY_THRESHOLD = 8; //阈值：当桶中有8个元素就把链表转为红黑树（选择8的原因是符合泊松分布）
		/* 0:    0.60653066
     * 1:    0.30326533
     * 2:    0.07581633
     * 3:    0.01263606
     * 4:    0.00157952
     * 5:    0.00015795
     * 6:    0.00001316
     * 7:    0.00000094
     * 8:    0.00000006
     * more: less than 1 in ten million
     */

static final int UNTREEIFY_THRESHOLD = 6; //小于等于6转化为链表

transient Node<K,V>[] table; 

transient Set<Map.Entry<K,V>> entrySet;
//transient: Java语言的关键字，变量修饰符，如果用transient声明一个实例变量，当对象存储时，它的值不需要维持。换句话来说就是，用transient关键字标记的成员变量不参与序列化过程

 int threshold; //阈值：当放下一元素后size等于threshold（它等于容量乘负载因子）就会扩容（resize（乘2）和rehash

static final int hash(Object key) { //防止有些对象的hashcode设计的非常差（不够散列），会导致严重的碰撞，所以要对传入对象的hashcode再进行一次散列
    int h;
    return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16); //防止有些传入的对象hashcode低位相同，高位不同，导致的冲突，所以在这里把低位和高位异或（无进位的加法）
}

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;
        if ((tab = table) == null || (n = tab.length) == 0) //一开始new出的hashmap的table是为空的(hashmap.size==0)，所以第一次put的时候对它初始化
            n = (tab = resize()).length; //用resize初始化
        if ((p = tab[i = (n - 1) & hash]) == null)
            tab[i] = newNode(hash, key, value, null);
        else {
            Node<K,V> e; K k;
            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 {
              //尾插法（1.7用的头插法,在resize()时也采用头插法)，头插法会改变hash桶中原本的顺序，
              //如果在多线程的情况下可能会导致所有线程调度完后，形成循环链表，而一旦进入其中就会死锁），
              //因为引入红黑树也将原本尾插法的O(n)转换为O(logn)
                for (int binCount = 0; ; ++binCount) { 
                    if ((e = p.next) == null) { //p是put进来的对象应该放入哪个hash桶
                        p.next = newNode(hash, key, value, null);
                        if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
                            treeifyBin(tab, hash); //如果hash桶长度大于等于阈值，就转化为红黑树
                        break;
                    }
                    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;
    }

resize()

else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && 
         oldCap >= DEFAULT_INITIAL_CAPACITY)   // 新的容量等于旧的容量*2，如果新的容量小于最大容量且大于等于初始容量，新的threshold也等于旧的乘2
    newThr = oldThr << 1; // double threshold   

index = HashCode（Key） & （Length - 1)//Hash的公式
/*为什么hashmap的容量必须是2的幂？
因为hash值的范围是2的-31次方到正的31次方，要映射到hashmap的容量内就要对容量取余，为了效率，实际采用的是hash&（len-1），达到的效果和%是相同的。
原理： 比如说容量为len=16；任何一个hash&（1111）结果就是它的低4位，完成了取余操作，但是如果len等于17，hash&（10000），毫无作用。
*/