今天主要和大家一起看一下JDK1.8里面HashMap类的putValue的原理。
分析能力有限，有错误欢迎指出。 废话不多说开始把！
今天要分析的就是这个方法
final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) 首先看一下源码
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; //重新计算一下大小
//获取要插入元素在 哈希桶中的位置
if ((p = tab[i = (n - 1) & hash]) == null) //如果这个位置没有Node
// return new Node<>(hash, key, value, next);
tab[i] = newNode(hash, key, value, null); //直接创建一个新的Node
else { //原来这个桶的位置上有Node
Node<K,V> e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k)))) //如果你和桶上的第一个Node相等
e = p; //直接覆盖值
else if (p instanceof TreeNode)//如果 你定位到的元素是一个TreeNode(Node的一个子类，也是HashMap的一个内部类)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);//那么就插入一TreeNode节点
else {//定位到这个hash桶了 但是这里面是链表（没有进行过树化）
for (int binCount = 0; ; ++binCount) {//是链表
if ((e = p.next) == null) {
//如果p节点的next为空 直接在后面插入
p.next = newNode(hash, key, value, null);
//这里的树化是putValue的时候 如果本来是链表 而且长度超过了8 那么就进行树化
if (binCount >= TREEIFY_THRESHOLD - 1)
//** 这个方法一会来分析
treeifyBin(tab, hash);
break;
}
//如果下一个节点e 不为null 并且这个链表中的节点就是你要找的节点 终止循环
if (e.hash == hash &&((k = e.key) == key || (key != null && key.equals(k))))
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;// 修改次数+1 和fastRemove()有关也和并发修改有关
if (++size > threshold) //如果大于了阙值 需要扩容的大小
resize(); //重新设置hash桶的大小，也有可能进行树化，见后面代码
afterNodeInsertion(evict);//空方法
return null;
}有三个方法需要跟进去看看
1. resize()
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table; // oldTable:当前的表
int oldCap = (oldTab == null) ? 0 : oldTab.length; //如果你是新创建的话 表的大小就是0 否则就是原来的大小
//第一次是为0的 代表 static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
int oldThr = threshold;
int newCap, newThr = 0; //新的容量和新的扩容
//如果旧的容量大于0
if (oldCap > 0) {
//如果旧的容量大于最大的容量
if (oldCap >= MAXIMUM_CAPACITY) {
//那么扩容大小 = 最大范围
threshold = Integer.MAX_VALUE;
//直接返回了
return oldTab;
}
//否则 如果新的大小等于 oldCap * 2 < 最大的容量 ， 并且旧的容量大于默认的初始化大小16
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
// double threshold 新的扩容 = 旧的扩容 * 2
newThr = oldThr << 1;
}
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr; //如果旧的扩容本来就大于0，那么新的容量就是旧的扩容
else { // zero initial threshold signifies using defaults 说明是 threshold为0的时候的情况
newCap = DEFAULT_INITIAL_CAPACITY; //新的容量为默认容器的容量
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); //新的阙值为 默认的容量 * 负载因子
}
if (newThr == 0) { //如果新的扩容为0
float ft = (float)newCap * loadFactor; //计算得到新的阙值
//新的阙值 = 如果新的容量小于 最大的容量 并且 新的阙只 < 最大的容量 那么新的阙值 = 计算的 否则 = 最大int
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) {
//遍历旧的hash桶
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {//如果旧的hash桶的元素不为null e为旧的hash桶的元素
oldTab[j] = null; //旧的hash桶设置为null
if (e.next == null) //如果你就是一个元素
newTab[e.hash & (newCap - 1)] = e; //那么在新的hash桶给你安排一个位置 位置是你的hash值 & 新的桶的容量-1 这相当于 你的hash值 与 你的容量进行取模运算
else if (e instanceof TreeNode) //如果你不只一个元素并且是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);
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead; //赋值 （原来位置）
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;//在新链表的位置赋值
}
}
}
}
}
return newTab;
}2.final void split(HashMap< K,V > map, Node< K,V >[] tab, int index, int bit)
上述方法在resize()过程中被调用
//被调用的代码 split(当前hash表，新的哈希桶，要分割的元素的小标，旧的容量)
((TreeNode
final void split(HashMap<K,V> map, Node<K,V>[] tab, int index, int bit) {
TreeNode<K,V> b = this; //这里的this : e = oldTab[j] 上下文中的代码
// Relink into lo and hi lists, preserving order
TreeNode<K,V> loHead = null, loTail = null; //低位的头和低位的尾
TreeNode<K,V> hiHead = null, hiTail = null; //高位的头和高位的尾
int lc = 0, hc = 0; //地位和高位的2个计数器
for (TreeNode<K,V> e = b, next; e != null; e = next) {
next = (TreeNode<K,V>)e.next; //获取下一个节点
e.next = null; //设置为null
if ((e.hash & bit) == 0) { //如果 e.hash 与 原来旧的容量 & 为 0 说明不需要进行移动位置 (e.hash & (bit-1) ) <==> e.hash % bit , e.hash & bit 计算的就是新增出来的那一位 如果结果为0 说明不需要进行位移
if ((e.prev = loTail) == null) //如果低位的尾巴为null
loHead = e; //将e 复制给头
else
loTail.next = e; //如果尾巴不为null 尾巴的next 为 e
loTail = e; //将e 作为新的尾巴
++lc; //次数 + 1
}
else {
if ((e.prev = hiTail) == null) //否则需要移动位置
hiHead = e; //高位的链表和低位一样
else
hiTail.next = e;
hiTail = e;
++hc;
}
}
if (loHead != null) { //如果有链表
if (lc <= UNTREEIFY_THRESHOLD) //如果长度 <= 6
tab[index] = loHead.untreeify(map);//取消树化 将这个树里面的链表结构变成普通的链表结构
else {
tab[index] = loHead; //否则将地位复制给原来的下标
if (hiHead != null) // (else is already treeified)
loHead.treeify(tab); //进行树化
}
}
if (hiHead != null) {
if (hc <= UNTREEIFY_THRESHOLD) hc < = 6;取消树化
tab[index + bit] = hiHead.untreeify(map);//进行了移位 位置偏移 下标 + 原来的容器大小
else {
tab[index + bit] = hiHead;
if (loHead != null)
hiHead.treeify(tab);
}
}
}这里面设计到2个方法在resize中 如果链表的长度 <= UNTREEIFY_THRESHOLD
就进行非树化，否则就进行树化。这里的非树化就是将TreeNode转换成Node
final Node<K,V> untreeify(HashMap<K,V> map) {
Node<K,V> hd = null, tl = null;
for (Node<K,V> q = this; q != null; q = q.next) {
//将q转换成普通的Nod return new Node<>(p.hash, p.key, p.value, next);
Node<K,V> p = map.replacementNode(q, null);
if (tl == null)
hd = p; //头为p
else
tl.next = p;
tl = p;
}
return hd;//返回这个链表
}树化为相反的过程
/**
* Forms tree of the nodes linked from this node.
* @return root of tree
*/
下面的这个方法也在hashMap中的putVal方法中的 treeifyBin(tab, hash);被调用
如果当时插入元素在hash桶为普通链表的情况下并且链表的长度大于8 就进行树化
final void treeify(Node<K,V>[] tab) {
TreeNode<K,V> root = null;
//初始化x 就是这个节点
for (TreeNode<K,V> x = this, next; x != null; x = next) {
next = (TreeNode<K,V>)x.next; //获取x的下一个节点
x.left = x.right = null; //设置x的左右为null
if (root == null) {
x.parent = null;
x.red = false; //根节点为黑色
root = x; //根节点为x
}
else { //根节点不为null
K k = x.key; // 获取K key
int h = x.hash; //获取hash
Class<?> kc = null; //获取数据的类型
//开始循环构建 将根节点复制给p
for (TreeNode<K,V> p = root;;) {
int dir, ph; //ph 当前节点的hash值
// dir 判断左右用的
K pk = p.key;
if ((ph = p.hash) > h)
dir = -1;
else if (ph < h)
dir = 1;
else if ((kc == null &&
(kc = comparableClassFor(k)) == null) ||
(dir = compareComparables(kc, k, pk)) == 0)
dir = tieBreakOrder(k, pk); //当 hashCode相等 并且没有比较器的时候 进行另外的一种方式比较 可以看一下源码
TreeNode<K,V> xp = p;
if ((p = (dir <= 0) ? p.left : p.right) == null) { //如果p节点的左儿子或者右儿子为null 那么就开始创建 否则就继续往下面找
//通过大小比较 判断 如果新的p（原来p的子节点） 为null
x.parent = xp; //x.parent就是当前的p
if (dir <= 0)
xp.left = x;
else
xp.right = x;
root = balanceInsertion(root, x);//红黑树的插入 把新的节点插入到当前树中 新的节点的parent就是你当前遍历的节点 而且当前遍历的节点的左儿子/右儿子已经确定
break;
}
}
}
}
moveRootToFront(tab, root);
}
//红黑树的插入
static <K,V> TreeNode<K,V> balanceInsertion(TreeNode<K,V> root,
TreeNode<K,V> x) {
x.red = true; //将要插入的节点设置为红色
//修正树
for (TreeNode<K,V> xp, xpp, xppl, xppr;;) {
// xp 为 要插入节点的爸爸
// xpp 为要插入节点的爷爷
// xppl 要插入节点的爷爷的左孩子
// xppr 要插入节点的爷爷的右孩子
if ((xp = x.parent) == null) { //如果他的爸爸为null
x.red = false; //就将他设置为黑色
return x; //直接返回 根节点
}
else if (!xp.red || (xpp = xp.parent) == null) //如果 爸爸是黑色 不影响红黑树的性质 //或者他是红色 并且他的爷爷为空 说明他爸爸就是根 也直接返回 符合性质 黑色下面是2个红色
return root; //那么直接返回root
if (xp == (xppl = xpp.left)) { //如果爸爸(红色) 是爷爷的左儿子
if ((xppr = xpp.right) != null && xppr.red) { //叔叔节点不为空并且是红色
xppr.red = false; //叔叔变成黑色
xp.red = false; //爸爸变成黑色
xpp.red = true; //爷爷变成红色
x = xpp; //当前节点指向爷爷节点
}
else { //叔叔为null 或者 叔叔为黑色（若存在）
if (x == xp.right) { //如果你是爸爸的右孩子 并且叔叔是黑色
root = rotateLeft(root, x = xp); //将父节点作为当前节点 //新的当前节点进行左旋
xpp = (xp = x.parent) == null ? null : xp.parent; // xp 为旋转后的当前节点的父亲
// xpp 如果xp都为空了 那么xpp 也为空 否则 xpp = xp.parent
}
if (xp != null) {
xp.red = false; //将父节点设置为黑色
if (xpp != null) {
xpp.red = true; //将祖父节点设置为红色
root = rotateRight(root, xpp); //对祖父节点进行右旋
}
}
}
}
else { //这里为父亲为右孩子的情况与左边类似 不在复述
if (xppl != null && xppl.red) {
xppl.red = false;
xp.red = false;
xpp.red = true;
x = xpp;
}
else {
if (x == xp.left) {
root = rotateRight(root, x = xp); //对你爸爸进行右旋
xpp = (xp = x.parent) == null ? null : xp.parent;
}
if (xp != null) {
xp.red = false;
if (xpp != null) {
xpp.red = true;
root = rotateLeft(root, xpp);
}
}
}
}
}
}3. moveRootToFront(tab, root);
/**
* Ensures that the given root is the first node of its bin.
*/
static <K,V> void moveRootToFront(Node<K,V>[] tab, TreeNode<K,V> root) {
int n;
if (root != null && tab != null && (n = tab.length) > 0) {//如果根存在
int index = (n - 1) & root.hash; //获取根在的hash桶的下标
TreeNode<K,V> first = (TreeNode<K,V>)tab[index]; //获取对应的节点
if (root != first) { //如果根不是第一个
Node<K,V> rn; // rootnext
tab[index] = root; //将根设置为第一个
TreeNode<K,V> rp = root.prev; //rootprev 根的前面一个
if ((rn = root.next) != null) //如果根的next 不为null
((TreeNode<K,V>)rn).prev = rp; // root.next的prev = root.prev
if (rp != null) //如果root.prev不为null
rp.next = rn; //root.prev的下一个 = root.next
if (first != null) //如果first第一个不为null
first.prev = root; 第一个的前面为root
root.next = first; //跟的后面为原来的第一个
root.prev = null; //根的前面为null
}
assert checkInvariants(root);
}
}
扫一扫
422
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
