Collections之HashMap知识点

源码原理分析

数据结构：（1）数组+链表+红黑树（jdk>=8）
（2）数组+链表（jdk1.7之前）

1、重要成员变量

DEFAULT_INITIAL_CAPACITY = 1 << 4; Hash表默认初始容量
MAXIMUM_CAPACITY = 1 << 30; 最大Hash表容量
DEFAULT_LOAD_FACTOR = 0.75f；默认加载因子
TREEIFY_THRESHOLD = 8；链表转红黑树阈值
UNTREEIFY_THRESHOLD = 6；红黑树转链表阈值
MIN_TREEIFY_CAPACITY = 64；链表转红黑树时hash表最小容量阈值，达不到优先扩容。

2、hashmap初始容量值的修改

public static void main(String[] args) {
    Map map = new HashMap(11);
    map.put("a",6);
}

先给出结论，我们在上面初始化了一个Hashmap的初始容量为11，但是它的初始化容量不是11，而是16，具体分析如下：

private void inflateTable(int toSize) {
    // Find a power of 2 >= toSize
    // roundUpToPowerOf2 方法会将一个数值强行转化为2的n次幂
    int capacity = roundUpToPowerOf2(toSize);
    threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
    table = new Entry[capacity];
    // 这里就是初始化hashcode
    initHashSeedAsNeeded(capacity);
}

由上述的源码可知，当Java发现我们传入的toSize不是2的n次幂时，hashmap会自动帮我们将初始值转化为大于初始值toSize并且最接近toSize的2的n次幂。
hashmap初始化容量为什么要是2的n次幂呢？

int a = x%2^n;
int b = x&(x^n-1)

假如数组length=16，hashcode经过运算后的结果应该是0~15；同时我们都知道，位运算会比四则运算快很多，所以我们选择位运算，则有一个条件是hash表的容量必须是2的n次幂。（扩容后也是一样）

3、jdk7的hashmap扩容会引起死锁问题

在haspmap扩容时，会先复制原来的hash表，由于在put方法解决hash冲突采用的是头插法，所以在扩容时，如果之前数组产生过hash冲突的几个数据在rehash之后放到新数组中仍然产生hash冲突，那么就会把数据翻过来，如果是多线程的话，就会产生闭环，出现死锁。
产生问题的原因：rehash之后用了头插法就产生了这种问题。
复制数据源码如下：

void transfer(Entry[] newTable, boolean rehash) {
    int newCapacity = newTable.length;
    for (Entry<K,V> e : table) {
        while(null != e) {
            Entry<K,V> next = e.next;
            if (rehash) {
                e.hash = null == e.key ? 0 : hash(e.key);
            }
            int i = indexFor(e.hash, newCapacity);
            // 就是下面这几行代码导致了链表的反转
            e.next = newTable[i];
            newTable[i] = e;
            e = next;
        }
    }

4、jdk8解决jdk7扩容死锁问题

jdk的扩容方法：（在hashMap类的resize()方法）

Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
    next = e.next;
    // 与我们的容量取 & 运算，比如说容量是16 ，则只会得出结果为16 或者 0
    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;
}
// 高位数组会放在槽位数值加上旧的数组容量（也就是16）的新数组槽位下
if (hiTail != null) {
    hiTail.next = null;
    newTab[j + oldCap] = hiHead;
}

首先这段代码去掉了rehash，并且定义了四个指针 loHead ，loTail ，hiHead ，hiTail 。
代码中也可以看到会去做 & 运算，结果会产生高低位，16 算高位，0 算低位，将会把一条链表分为两条链表，低位的话直接挪到新数组相同的槽位下，高位数组会放在槽位数值加上旧的数组容量（也就是16）的新数组槽位下，这样就避免了头插法形成的闭环，在代码中看注释这就话就很容易理解了。
这是数学的推理，记住结论即可，当然数组的容量必须是2的n次幂。

5、jdk8的hashmap链表和红黑树转换

jdk8的hashmap链表与红黑树的转换规则：
（1）条件成立：当hashmap容量大于等于 64 时，并且一个位桶数组上的长度大于8时，才会将链表转换为红黑树。
（2）条件不成立：如果只有链表长度大于8，而容量小于64时，是优先扩容的。
源码如下：

final void treeifyBin(Node<K,V>[] tab, int hash) {
    int n, index; Node<K,V> e;
    // MIN_TREEIFY_CAPACITY 的值为64
    if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
    	// 条件不成立，扩容
        resize();
    else if ((e = tab[index = (n - 1) & hash]) != null) {
    	// 条件成立，链表转红黑树
        TreeNode<K,V> hd = null, tl = null;
        do {
            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);
    }
}