「这是我参与11月更文挑战的第18天，活动详情查看：2021最后一次更文挑战」
接上一篇集合和HashMap（二）
6) get()
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
if ((tab = table) != null && (n = tab.length) > 0 && (first = tab[(n - 1) & hash]) != null) {
// 永远检查第一个node
if (first.hash == hash && ((k = first.key) == key || (key != null && key.equals(k))))
return first;
if ((e = first.next) != null) {
if (first instanceof TreeNode) // 树查找
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
do {
// 遍历链表
if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}
在Hashmap1.8中，无论是存元素还是取元素，都是优先判断bucket上第一个元素是否匹配，而在1.7中则是直接遍历查找。
基本过程如下:
1. 根据key计算hash;
2. 检查数组是否为空，为空返回null;
3. 根据hash计算bucket位置，如果bucket第一个元素是目标元素，直接返回。否则执行4;
4. 如果bucket上元素大于1并且是树结构，则执行树查找。否则执行5;
如果是链表结构，则遍历寻找目标
7) 扩容resize()
构造hash表时，如果不指明初始大小，默认大小为16（即Node数组大小16），如果Node[]数组中的元素达到（填充比*Node.length）重新调整HashMap大小 变为原来2倍大小,扩容很耗时
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table; //首次初始化后table为Null
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold; //默认构造器的情况下为0
// newCap:新数组长度；newThr:新数组长度
int newCap, newThr = 0;
if (oldCap > 0) { **//table扩容过******
//当前table容量大于最大值得时候返回当前table
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
//把新表的长度设置为旧表长度的两倍newCap=2*oldCap
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&oldCap >= DEFAULT_INITIAL_CAPACITY)
//table的容量乘以2，threshold的值也乘以2
newThr = oldThr << 1; // double threshold
}
**//使用带有初始容量的构造器table容量为初始化得到的threshold******
else if (oldThr > 0)
newCap = oldThr;
else { **//默认构造器下进行扩容**
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; //把新表赋值给table
if (oldTab != null) { //原表不是空把原表数据移动到新表中 /*遍历原来的旧表*/
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;//置空，不在指向任何对象了
//e的元素没有下一个节点(只有一个节点)
if (e.next == null)
//把此元素放入新数组种
newTab[e.hash & (newCap - 1)] = e;
//当前index对应的节点为红黑树
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { //链表
//把当前index对应的链表分成两个链表，减少扩容的迁移量
// loHead:低位的头；loTail:低位尾巴
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);
//lo队不为null，放在新表原位置
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
//hi队不为null，放在新表j+oldCap位置
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
(e.hash & oldCap) == 0 分析： 原索引,(e.hash & oldCap) == 0 通过hashmap的特点可以得知,hashmap的容量是2的N次幂,e.hash & oldCap==0,说明此时e.hash小于原来数组的长度,因为索引的计算方式是(e.hash & (newCap - 1)) 所以Node的索引不会发生改变。
