JDK版本:1.8.0_201
首先说明,在这篇文章中,不涉及HashMap链表树化的过程,树化会在另外一篇文章中讲解。那么就不整花里胡哨的,直接上源码
put方法,先用自定义方法计算hash,然后调用putVal方法:
public V put(K key, V value) {
//这里要先用HashMap自己定义的方法计算key的哈希值
return putVal(hash(key), key, value, false, true);
}
自定义方法计算hash
//hashCode是32位,右移16位后与原hashCode进行异或运算,然后返回结果
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
//jdk默认的hashCode()方法返回的是int型,长度为4字节,即32位
public native int hashCode();
put的关键方法—putVal:
1.举例:第一次插入元素,(tab = table) == null || (n = tab.length) == 0,调用resize方法,返回值为一个长度为16的节点数组(table),且threshold=12,table与resize返回值相同。接下来判断(p = tab[i = (n - 1) & hash]) == null,其中,(n - 1) & hash是寻址算法,是用于确定元素的位置,用这种方式可以避免元素越界和尽量减少碰撞。因为此时是第一次插入元素,所以结果肯定是true,执行tab[i] = newNode(hash, key, value, null),得到一个节点,赋给tab[i],i 就是刚刚与运算出来的位置。最后判断++size > threshold,这里第一次++size,size=1,小于threshold(12),返回空,结束,afterNodeInsertion(evict);是空方法,无实际意义。
2.举例:第二次插入,假设元素的hash和第一次插入的相同,则前两个判断都不成立,进入第二个判断的else区。else中第一个判断的意思是,插入的元素是否和原有的元素相同,如果是,则把原有的p元素赋给节点e。下一个判断条件为p instanceof TreeNode,这是判断p是否为红黑树的节点类型,这里显然不是。接下来的一个循环,起到插入元素的作用,遍历p.next是否为空,其中还有一个if,用于判断是否需要扩容和转化为红黑树。这里因为是第二次插入,所以第一轮循环就插入成功了。下面再次判断++size > threshold,不成立,只是size+1。返回空,结束。
3.举例:第九次插入,假设前八次插入元素(看上去是,数组中一个元素,链表中存了7个元素)的hash和第九次插入的都相同。直接走第一个else,同hash但是不同key,且不是红黑树类型节点,进入链表插入环节,在循环过程中,恰好满足 binCount >= TREEIFY_THRESHOLD - 1 条件,进入treeifyBin方法。执行完treeifyBin方法方法之后,++size,再次与threshold比较,此时,threshold =24,大于size =10,返回null,结束。
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)
n = (tab = resize()).length;
//判断是否产生哈希冲突
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
//下面时第一个else
else {
Node<K,V> e; K k;
//判断是否为重复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) {
p.next = newNode(hash, key, value, null);
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;
}
}
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方法:
1.第一次插入元素时,table==null,oldCap=0,oldThr =16(如果通过无参构造方法产生,具体看调用构造方法时产生的oldThr ),newCap, newThr = 0;后通过oldThr > 0的判断,执行newCap = oldThr,即newCap=16,再通过 newThr = = 0 的判断,
执行结果为newThr = ft = (float)newCap * loadFactor = 16*0.75 = 12,然后threshold = newThr ;
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap]; table = newTab;
此时,threshold =12,创建了一个newTab,长度为16的节点数组,然后赋值给table ,最后返回newTab。
2.第二次插入元素时,不涉及resize方法。
3.第九次插入元素时,oldCap=oldTab.length=16,oldThr =threshold=12,判断第一个if,成立,但是oldCap < MAXIMUM_CAPACITY,判断else if,(newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY,因为oldCap=16,左移一位为32,远小于MAXIMUM_CAPACITY,且刚好等于DEFAULT_INITIAL_CAPACITY,所以执行下面的语句,newThr = oldThr << 1。此时,newCap =32,newThr =24。接下来threshold = newThr =32,创建一个32大小的新表(newTab),并赋给table。接下来的操作是把oldTab中的元素重新进行排列,老链表上的元素拆分保存到高位链表或低位链表上,,用的判断是 e.hash & oldCap) == 0,非常巧妙地决定了新位置是在高位或者低位,低位表的位置和老表的位置相同,因为与出来首位是0,高位表的位置是老表的位置加上老表的长度,之后用了一个do while循环,将老链表上的所有元素就都转移到高低位链表上,循环结束后,把高低位表的头节点挂到新表上,最后返回这个新表。
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
//第一个if
if (oldCap > 0) {
//第二个if
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
else { // zero initial threshold signifies using defaults
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;
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
//如果只有数组上有一个元素,而没有链化的时候,就直接把这个元素重新寻址存放
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;
do {
next = e.next;
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;
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
newNode方法:返回一个节点
Node<K,V> newNode(int hash, K key, V value, Node<K,V> next) {
return new Node<>(hash, key, value, next);
}
treeifyBin方法:如果传入的链表为空,或者链表长度小于64,进入resize方法,对哈希数组进行扩容,否则进行树化。
final void treeifyBin(Node<K,V>[] tab, int hash) {
int n, index; Node<K,V> e;
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);
}
}