resize函数
因为HashMap的构造函数 并不会给内部的表开辟空间
transient Node<K,V>[] table;
而是在调用put函数时(put函数内部再调用putVal方法) 如果表为空则调用resize方法
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)
//调用resize方法
n = (tab = resize()).length;
//....
}
换句话说 resize函数不得不 考虑 任何不同形式的构造函数 及带一参 带两参 不带参的hashMap " 调用 "resize方法
//无参构造器调用put方法
HashMap<String,String> hashMap=new HashMap<>();
hashMap.put(1,1);
//一参构造器调用put方法
HashMap<String,String> hashMap=new HashMap<>(62);
hashMap.put(1,1);
//...
所以整个 的大概思路
-
将旧表保存下来
-
将 旧表的长度 临界值 等信息保存下来 如果旧表为空则长度为0
-
声明新表的长度 新表的临界值
-
如果旧表中有元素
就分为多种情况了
第一种就是- 4.1
有可能表的容量已经达到最大值了 所以需要判断是否达到最大长度 到达则无需再 散列
第二种的话
-4.2
就是旧表中有元素 并且没达到最大值 那么就可以再散列了
这样给新表的容量赋值才有意义 当然这里也有个限制就是旧表的容量要大于16
- 4.1
-
如果旧表中 没有元素 并且 旧表有临界值 那么 就是这种构造函数调用的 new HashMap(50); 所以要将 newCap=oldThr;
-
否则 在表为空 又没有临界值 指定新表的长度和临界值
-
如果newThr还没被指定 如果没有 则指定 也就是说在旧表有指定临界值时的时候调用
-
前期值的赋值准备做好了就可以再散列了
简而言之:
put内部会调用 resize方法 此时resize方法就必须的知道此时HashMap是通过什么方式构造的
如果是无参的方式构造 就指定容量和临界值
一参的方式构造 就指定临界值
resize最开始的if else就是为了判断是什么构造器调用的
if (oldCap > 0) {
//如果旧表长度大于最大容量 简而言之 太长了
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
//不能增加长度
//返回原始表
return oldTab;
}
//如果旧表的长度大于16 才需要计算临界值(threshold)s
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold 这里是旧的阈值的两倍
}
//在oldTab为null的情况下 如果 oldThr>0 说明有指定初始容量
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);
}
//newThr还没被指定吗 如果没有 则指定 也就是说在旧表有指定临界值时的时候调用
if (newThr == 0) {
float ft = (float)newCap * loadFactor;
//确定新的临界值
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
threshold = newThr;
by the way
当表中的数量 超过临界值时 也会调用resize方法
如何再散列
大概思路
- 如果表中的节点是树节点 则直接调用 splite
- 如果不是树节点 也就是 普通的节点
会怎么做呢?
这里有个很有意思的地方 e.hash & oldCap
这是为什么呢
根据源码表示的是链表中的每一个元素都要再散列 为什么都要再散列
首先必须明确的是 键存放在哪个桶中取决于他的hash值
并且存放在同一个桶中的hash值不一定相等 比如 长度为16 hash为5的元素hash为21的元素
都会在同一个桶中 通过 e.hash & oldCap就可以为元素分类了
如果e.hash是oldCap的奇数倍 则结果为oldCap 89是16的奇数倍 89/16=5 所以89 & 16 为16 如果e.hssh是oldCap的偶数倍 则结果为0 70/16=4 所以70 & 16 为0 也就是说任何hash值要么为0要么为oldCap即不为0 为0的由low负责不为0的由hight负责
如果为hight则将其分配在tab[j+oldCap]中
简而言之:
它是通过for循环遍历桶中的链表
通过 e.hash & 旧表长度 将 同一桶中的元素 分为较高部分和较低部分
较低部分直接存放到 较高的部分则存放在j+oldCap中
以下是具体的源码注释
final Node<K,V>[] resize() {
//threshold表示要调整大小的下一个值
//将之前的table 保存起来
Node<K,V>[] oldTab = table;
//旧表长度
int oldCap = (oldTab == null) ? 0 : oldTab.length;
//旧的临界值 此时threshold已经在构造函数中完成了初始化
int oldThr = threshold;
//新表长度 新表的要调整的下一个值
int newCap, newThr = 0;
if (oldCap > 0) {
//如果旧表长度大于最大容量 简而言之 太长了
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
//不能增加长度
//返回原始表
return oldTab;
}
//如果旧表的长度大于16 才需要计算临界值(threshold)s
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold 这里是旧的阈值的两倍
}
//在oldTab为null的情况下 如果 oldThr>0 说明有指定初始容量
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);
}
//newThr还没被指定吗 如果没有 则指定 也就是说在旧表有指定临界值时的时候调用
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)
//e.hash & 最大索引 & 只有存在两个一则为一 0 和本身
//再散列
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;
//loHead 为 lowHead
//loTail 为 lowTail
Node<K,V> hiHead = null, hiTail = null;
//hiHead 为 hightHead
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);
//链表的最后一个设为null
if (loTail != null) {
loTail.next = null;
//映射链表
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}