HashMap学习篇resize（）的扩容机制（JDk1.8）
数据丢失（在put时,例如：挂载数据到链表时，线程2覆盖线程1）
JDK1.7的死循环 扩容时，头插法弊端链表数据相互引用
先提一下HashMap的底层数据结构为数组+链表+红黑树。
put（）代码解析
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
//判断hashMap原容器是否初始化内存空间
if ((tab = table) == null || (n = tab.length) == 0)
//当判断能为空时，进行hashMap的扩容
n = (tab = resize()).length;
// 注意：(n - 1) & hash才是真正的hash值，也就是存储在table位置的index
if ((p = tab[i = (n - 1) & hash]) == null)
//如果没有保存，说明可以直接保存
tab[i] = newNode(hash, key, value, null);
else {
//如果发现不是null说明，需要进行链表挂载
Node<K,V> e; K k;
// 如果在首结点与我们待插入的元素有相同的hash和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);
// 当遍历的结点数目大于8时，则采取树化结构。
if (binCount >= TREEIFY_THRESHOLD - 1)
treeifyBin(tab, hash);
break;
}
if (e.hash == hash &&((k = e.key) == key || (key != null && key.equals(k))))
// 如果找到与我们待插入的元素具有相同的hash和key值的结点，则停止遍历。此时e已经记录了该结点
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;
//当siez扩大一个大于临界扩容值时，进行扩容操作
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
}
1.数据初始化
//将之前的数组的数据保存出来
Node<K,V>[] oldTab = table;
//获取之前保存数据的长度，防止未初始化报错
int oldCap = (oldTab == null) ? 0 : oldTab.length;
//获取之前扩容临界值(capacity*loadFactor)
int oldThr = threshold;
//初始化新的容器参数
int newCap, newThr = 0;
2.生成新容器的容量和扩容临界点
//判断旧容量有值时
if (oldCap > 0) {
//当他大于等于限制的最大容量时(这里可以理解成扩容失败,旧容器的容量值已经超过了默认最大容量,只能将容器的临界值修改为int最大21E)
if (oldCap >= MAXIMUM_CAPACITY) {
//扩容临界值默认使用Integer的最大值
threshold = Integer.MAX_VALUE;
//然后返回之前的数组结构,将扩容临界值设置为MAXIMUM_CAPACITY，”未进行扩容，只是将扩容临 界值扩大为Integer的最大值"
return oldTab;
}
//判断 之前的长度扩大一倍是否会大于默认的最大长度 并且之前的长度是否大于默认长度16(这里的目的是为了判断容量扩大一倍后是否会超过默认值,如果没有说明新容器可以使用这个容量，并且要大于默认值16)
//这里设置为@1
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&oldCap >= DEFAULT_INITIAL_CAPACITY)
//则将之前的扩容临界值扩大一倍
newThr = oldThr << 1; // double threshold
//当旧容量长度为0,并且扩容临界值大于0时，将新容量设置为扩容临界值(当Map的数据被清除完时，会出现这种情况)
//需要注意的是这里变化了newCap的长度，但是没有变化临界值的长度，这里做一个备注为@2
//这里验证了hashMap扩容因子的使用，因为oldThr=(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY) 直接将新容器容量设置为oldThr相当于将旧容器扩充了0.75
}else if (oldThr > 0) newCap = oldThr;
else {
//当旧容量长度为0,并且扩容临界值为0时，初始化长度为16 ，扩容临界点为（DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY）
//这个地方就是hashMap的初始化点
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
//@1的说明当长度为1时，并没有初始化扩容临界值时并且对@2没有初始化变化临界值的长度的补充
if (newThr == 0) {
float ft = (float)newCap * loadFactor;
//判断是否new容量是否大于最大值，临界值是否大于最大值，都满足是扩容为他自己否则为Integer最大类型
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
3.实现数据复制
//将刚刚判断好的临界值长度复制给现在对象的变化临界值，到这里就将当前对象的容器临界值设定完成
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) {
//把已经赋值之后的变量置位null，当然是为了好回收，释放内存
oldTab[j] = null;
//如果下标处的节点没有下一个元素，说明可以直接保存
if (e.next == null)
//把该变量的值存入newCap中，数组的坐标为 位运算结果 e.hash & (newCap - 1)
//详情可以看下面解析
newTab[e.hash & (newCap - 1)] = e;
//当next下面的直属数据大于1时，(JDk1.8使用的数组链表加红黑树，这里就是用的红黑树当 下面有多个时)，本文不作详解
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
//当只有一个时使用链表就是 5接2时
else {
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
next = e.next;
//判断0或者1 当e.hash超过了oldCap为！=0 没有超过时为0 详情也可以看下文
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;
}
这里解析一下位运算符&
首先说一下e.hash & (newCap - 1)
当e.hash=5 newCap=16 你会发现e.hash & (newCap - 1) 的值为5，
当e.hash=21 newCap=16 你会发现值同样是5
如果相同的判断都是这个值，那么就会实现链表的挂载或者红黑树，当扩容（成31时)之后你会发现保存的数据的Hash值位原值，一定程度上防止了保存数据的超出索引范围的现象
然后说一下e.hash & oldCap使用链表只挂5和21时，本人理解当挂多个时会自动生成红黑树所以不会走这里
当oldCap（初始容量为）16时，由上图可知，之前5和21都是挂载在索引为5的位置，当扩容为31后
将分别执行下面的代码，loHead为5的数据，hiHead为21的数据，并且分别清楚的next的数据
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
就会出现，由下图可知就将索引挂载的数据进行了分开
337
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
