HashMap 的底层实现原理(JDK8)

当实例化 HashMap 之后，不会立即创建数组(与JDK7比较)，当第一次添加元素的时候才会创建数组，下面代码都为 HashMap(JDK8) 的部分源码。

public HashMap() {
	this.loadFactor = DEFAULT_LOAD_FACTOR;
}

// resize() 中的部分代码
newCap = DEFAULT_INITIAL_CAPACITY; // DEFAULT_INITIAL_CAPACITY = 16
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap]; // 创建长度为16的 Node[]
table = newTab; // transient Node<K,V>[] table

在添加元素的时候，首先会调用 key 的 hashCode() 并做一个异或运算计算出一个哈希值，

public V put(K key, V value) {
	return putVal(hash(key), key, value, false, true);
}

static final int hash(Object key) {
	int h;
	return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

然后根据数组的长度减一(n 为数组长度)和之前算出来的哈希值做与运算，计算出此元素在数组中的存放位置，如果此位置上的数据为空则添加成功。

// putVal() 中的部分代码
if ((p = tab[i = (n - 1) & hash]) == null)
	tab[i] = newNode(hash, key, value, null);

如果此位置上的数据不为空(可能是一个数据也可能是多个数据(以链表形式存在))
①将此元素的哈希值和其他数据的哈希值作比较，如果都不相同则添加成功。

// putVal() 中的部分代码
if (p.hash == hash &&
	((k = p.key) == key || (key != null && key.equals(k))))

②如果此元素的哈希值和某一个数据的哈希值相同并且 key 的地址值也相同，则用新的 value 替换旧的 value。或者 key 不为空并且调用 key 所在类的 equals() 和这个数据进行比较，
如果 equals() 返回 false，则添加成功。
如果 equals() 返回 true，则用新的 value 替换旧的 value。

// putVal() 中的部分代码
if (e != null) { // existing mapping for key
	V oldValue = e.value;
    if (!onlyIfAbsent || oldValue == null)
        e.value = value;
    afterNodeAccess(e);
    return oldValue;
}

在不断的添加过程中，会涉及到扩容问题，当超出临界值且要存放的位置非空时，默认扩容为原来容量的2倍，并将原有的数据复制过来。

// resize() 中的部分代码
if (oldCap > 0) {
	if (oldCap >= MAXIMUM_CAPACITY) {
	     threshold = Integer.MAX_VALUE;
	     return oldTab;
	 }
	 // table 的容量扩容为原来的2倍
	 else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
	          oldCap >= DEFAULT_INITIAL_CAPACITY)
	     newThr = oldThr << 1; // double threshold
}

当数组的某一个索引位置上的元素以链表形式存放的数据个数大于等于8且当数组的长度大于等于64时，此时将索引位置上的所有数据改为红黑树存储。

// putVal() 中的部分代码
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 = e;
}

final void treeifyBin(Node<K,V>[] tab, int hash) {
	 int n, index; Node<K,V> e;
	 // 当数组长度小于 64 时，不会进行红黑树转换，仍然是扩容
	 if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
	     resize();
	 // 当数组的长度大于等于 64 时，转换为红黑树
	 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);
	 }
}