扩容操作可以认为是HashMap源码中最复杂的
resize方法的不是public的,不能通过client触发,所以只能直接进入源码查看
JDK 7
void resize(int newCapacity) {
Entry[] oldTable = table;
int oldCapacity = oldTable.length;
if (oldCapacity == MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return;
}
Entry[] newTable = new Entry[newCapacity];
boolean oldAltHashing = useAltHashing;
useAltHashing |= sun.misc.VM.isBooted() &&
(newCapacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);
boolean rehash = oldAltHashing ^ useAltHashing;//判断是否需要对原node重新hash定位table的index
transfer(newTable, rehash); //扩容核心方法
table = newTable;
threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
}
进入 transfer
方法
void transfer(Entry[] newTable, boolean rehash) {
int newCapacity = newTable.length;
for (Entry<K,V> e : table) {//直接遍历table变量
//链表跟table[i]断裂遍历,头部往后遍历插入到newTable中
while(null != e) {
Entry<K,V> next = e.next;
if (rehash) {
e.hash = null == e.key ? 0 : hash(e.key);
}
int i = indexFor(e.hash, newCapacity);
e.next = newTable[i];
newTable[i] = e;
e = next;
}
}
}
扩容过程总结:
创建一个新的数组newTable,容量是oldTable的一倍
遍历oldTable,拿到每个链表
遍历链表,头插法插入newTable
JDK 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;
//一系列校验
if (oldCap > 0) {
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
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) {//开始遍历oldTable
Node<K,V> e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
if (e.next == null) //table[i]没值
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode) //table[i]是红黑树的结构
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { //table[i]是链表的结构,扩容后还是保持顺序的
Node<K,V> loHead = null, loTail = null; //“低链表”的头和尾,即扩容后的在new table的index和old index是一样的
Node<K,V> hiHead = null, hiTail = null; //“高链表”的头和尾,即扩容后的在new table的index是old index的2倍
Node<K,V> next;
do {
next = e.next;
if ((e.hash & oldCap) == 0) {//newTable index == oldTable index
if (loTail == null)
loHead = e;//头只当初始时才赋值
else
loTail.next = e;//新插入的都到添加到tail中
loTail = e;
}
else {//newTable index == oldTable index * 2
if (hiTail == null)
hiHead = e;//头只当初始时才赋值
else
hiTail.next = e;//新插入的都到添加到tail中
hiTail = e;
}
} while ((e = next) != null);
if (loTail != null) { //将“低链表”添加到newTable中
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {//将“高链表”添加到newTable中
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
总结(先针对链表操作的总结,红黑树的后续文章会写):
如果是链表处理(红黑树的后续文章讨论),那么就将oldTable[i]分成高低链表,生成后插入到newTable中
对比
JDK7是每拿到一个Node就直接插入到newTable,而JDK8是先插入到高低链表中,然后再一次性插入到newTable。
所以链表的扩容过程JDK7会出现死循环问题,而JDK8避免了这个问题。
JDK8跟原先的链表对比Node之间顺序是一致的,而JDK7是是反过来的。