- put方法
樹化條件：桶的個數(shù)大于等于64時，并且新插入的key對應鏈表的長度大于等于7.
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);
}
final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) {
// hash表
Node<K, V>[] tab;
Node<K, V> p;
int n, i;
// 如果表為空或者表的長度為0，那么將會對hash表進行初始化
if ((tab = table) == null || (n = tab.length) == 0)
// 初始化的table的容量為16
n = (tab = resize()).length;
// i = (n - 1)&hash進行計算桶的位置，如果該桶中沒有鏈表直接創(chuàng)建一個新的鏈表
if ((p = tab[i = (n - 1) & hash]) == null) {
tab[i] = newNode(hash, key, value, null);
} else {
// 在桶內(nèi)取出原來的Node
Node<K, V> e;
K k;
// key的hash值與桶內(nèi)的第一個節(jié)點的hash值相等 && key值相等
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 {
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
// 遍歷鏈表，如果已經(jīng)遍歷到鏈表的末尾，還是沒有找到原來的節(jié)點，則新建一個node節(jié)點
p.next = newNode(hash, key, value, null);
// 如果新建的一個節(jié)點，查過樹化的臨界值，則進行樹化。
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
// 遍歷鏈表，如果在鏈表中找到了原來的那個節(jié)點，則取出
if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
// 對取出的節(jié)點重新賦值。
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)
// 如果hash表的容量超過了，擴容的臨界值，則進行擴容
resize();
afterNodeInsertion(evict);
return null;
}
final void treeifyBin(Node<K, V>[] tab, int hash) {
int n, index;
Node<K, V> e;
// 如果某個桶內(nèi)的鏈表的長度大于8，但是桶的個數(shù)小于64，此時不會進行樹化而是進行擴容
// 只有在桶的個數(shù)大于等于64時，并且將key插入一個長度大于等于8的鏈表中
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);
}
}
- resize 擴容
擴容發(fā)生的時機：
- 當hash表中元素個數(shù)大于擴容的臨界值
- 當表容量小于64時，并且某個桶內(nèi)的鏈表元素大于8時
final Node<K, V>[] resize() {
Node<K, V>[] oldTab = table;
// 獲取原來的表容量
int oldCap = (oldTab == null) ? 0 : oldTab.length;
// 原來的臨界值
int oldThr = threshold;
int newCap, newThr = 0;
// 如果原來的表容量大于0，說明已經(jīng)初始化完成了
if (oldCap > 0) {
// 如果原來的表容量已經(jīng)大于等于表容量的最大值了，那么直接將hash表的容量設置為int的最大值
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
} else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY) {
// 如果表容量大于初始化值并且小于擴容之后的最大值，則進行擴容。否則無法再進行擴容了。
newThr = oldThr << 1;
}
} else if (oldThr > 0) { // initial capacity was placed in threshold
// 通過HashMap(int cap, float load)構(gòu)造器進行構(gòu)造，cap為0時導致，threshold為1
newCap = oldThr;
} else {
// 此時的hash表未完成初始化，先對hash表進行初始化，初始化的容量為16，初始化的臨界值為16*0.75=12
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int) (DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
if (newThr == 0) {
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;
// 未初始化的hash表的容量為null,返回newTab
if (oldTab != null) {
// 對于已經(jīng)初始化完成的hash表，此時擴容的話需要將原來的hash表中的數(shù)據(jù)，放入新的hash表中。
// 通過循環(huán)原來的hash表，依次取出然后重新對hash值進行取模
for (int j = 0; j < oldCap; ++j) {
Node<K, V> e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
// 取出原來的桶中的鏈表長度為1（說明原來就沒有發(fā)生hash沖突），擴容之后就更不會發(fā)生hash沖突，所以可以直接放入新的桶中。
if (e.next == null) {
newTab[e.hash & (newCap - 1)] = e;
} else if (e instanceof TreeNode) {
((TreeNode<K, V>) e).split(this, newTab, j, oldCap);
} else { // preserve order
Node<K, V> loHead = null, loTail = null;
Node<K, V> hiHead = null, hiTail = null;
Node<K, V> next;
// 構(gòu)建兩條鏈表，lo鏈表將值放入原來的索引值之中，hi鏈表將值放入(原來的索引+oldCap)之中
do {
next = e.next;
// 當 (oldCap - 1) & hashCode == oldCap & hashCode 時，索引還是原來的
if ((e.hash & oldCap) == 0) {
if (loTail == null) {
loHead = e;
} else {
loTail.next = e;
}
loTail = e;
} else {
// 索引值為oldCap + j;
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
// 當 (oldCap - 1) & hashCode == oldCap & hashCode 時，索引還是原來的
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
// 當 (oldCap - 1) & hashCode == oldCap & hashCode 時, 索引值是oldCap + j
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
