一、put(key,value)
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true); //hash(key)，对于key进行hash运算
}
static final int hash(Object key) { //对于key进行hash运算的过程，为啥右移呢？还要或运算呢？为了让高位参与运算，不会只有低位进行有效的运算
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i; //tab是数组
if ((tab = table) == null || (n = tab.length) == 0) //第一次put元素数值的时候进入这里面，数组是null，我们进行扩容，n是扩容后数组的长度，点击扩容方法，如下面所示
n = (tab = resize()).length; //扩容后数组长度赋值给n
if ((p = tab[i = (n - 1) & hash]) == null) //p 表示数组的头节点，发现为null,说明新放入一个节点即可， (n-1) & hash 就相当于对 hash %n; 这样的目的是数组不会越界
tab[i] = newNode(hash, key, value, null); //传统的节点赋值的方法
else { //数组的位置的头节点不为null
Node<K,V> e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k)))) //先计算hash值，在计算key是否相等， 注意 == 和equals的区别
e = p; // e等于p,说明当前 e是头节点，就是表示e是该数组的头节点
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， 如果链表的长度大于8，注意binCount =0 开始，所以 >= 7, 且不要忘记 p是头节点，binCount = 0时，处理的是第二个节点，所以binCount = 7时，处理的是第9个节点，所以说链表的长度大于8，进行树化
treeifyBin(tab, hash);
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break; //在这找到了这个元素，跳出，此时e 为该元素在链表中的位置的节点
p = e;
}
}
//此处就是put相同的key,返回老的数值的地方
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(); //注意，此处是扩容，不是初始化，jdk1.8初始化和扩容放入一个方法里面了
afterNodeInsertion(evict);
return null;
}
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length; //第一次进入，数组是null，所以oldCap = 0 ； 第二次进入扩容方法，发现里面是老的数组的长度
int oldThr = threshold; //这个就是老的临界值
int newCap, newThr = 0; //新容量，新的临界值
if (oldCap > 0) { //如果老容量大于0，说明是扩容，非初始化
if (oldCap >= MAXIMUM_CAPACITY) { //老容量大于等于 1<<<30
threshold = Integer.MAX_VALUE; //临界值赋值为 2^31-1
return oldTab; //返回老的容量
}
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY) //没有大于 1<<< 30位的容量，就是正常扩容的条件，默认大于等于 16
newThr = oldThr << 1; // double threshold，就是双倍的临界值
}
else if (oldThr > 0) // initial capacity was placed in threshold //初始化方法，新容量就是 老的临界值， 老的临界值初始化计算的是 大于等于初始化容量的 2^n
newCap = oldThr;
else { // zero initial threshold signifies using defaults ，0初始化临界值容默认的
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
if (newThr == 0) { //初始化方法，默认 newThr = newCap* loadFactor; 新的临界值
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; //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); //遍历链表，看前边有个 e = e.next;
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
欢迎大佬指正
浙公网安备 33010602011771号