**/
static final float DEFAULT_LOAD_FACTOR = 0.75f;
/**
- 树化阈值:当桶中的元素个数大于8时进行树化
**/
static final int TREEIFY_THRESHOLD = 8;
/**
- 取消阈值:当一个桶中的元素个数小于等于6时把树转化为链表
**/
static final int UNTREEIFY_THRESHOLD = 6;
/**
- 最小树化阈值:当桶的个数达到64的时候才进行树化
**/
static final int MIN_TREEIFY_CAPACITY = 64;
/**
- 数组,又叫作桶(bucket)
**/
transient Node<K,V>[] table;
/**
- 作为entrySet()的缓存
*/
transient Set<Map.Entry<K,V>> entrySet;
/**
- 元素的数量
*/
transient int size;
/**
- 修改次数,用于在迭代的时候执行快速失败策略
*/
transient int modCount;
/**
- 当桶的使用数量达到多少时进行扩容,threshold = capacity * loadFactor
*/
int threshold;
/**
- 装载因子
*/
final float loadFactor;
- 容量
容量为数组的长度,亦即桶的个数,默认为16,最大为2的30次方,当容量达到64时会进行树化。
- 负载因子
负载因子用来计算容量达到多少时才进行扩容,默认负载因子为0.75。当容量超过3/4时扩容。
- 树化
树化,当容量达到64且链表的长度达到8时进行树化,当链表的长度小于6时反树化。
Node是一个典型的单链表节点,其中,hash用来存储key计算得来的hash值。
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> next;
}
上面了解了红黑树的一些性质和操作,接下来看看具体的实现。
4.1、TreeNode内部类
Node是红黑树的节点类。它继承自LinkedHashMap中的Entry类。
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
TreeNode<K,V> parent; // 父节点
TreeNode<K,V> left; //左孩子
TreeNode<K,V> right; //右孩子
TreeNode<K,V> prev; // 前置节点
boolean red; //红黑树的颜色
/**
- 构造函数
*/
TreeNode(int hash, K key, V val, Node<K,V> next) {
super(hash, key, val, next);
}
/**
- 返回根节点
*/
final TreeNode<K,V> root() {
for (TreeNode<K,V> r = this, p;😉 {
if ((p = r.parent) == null)
return r;
r = p;
}
}
//……
}
4.2、左旋
/**
- 红黑树左旋操作
**/
static <K,V> TreeNode<K,V> rotateLeft(TreeNode<K,V> root,
TreeNode<K,V> p) {
TreeNode<K,V> r, pp, rl;
//p不为null且p的右子树不为null
if (p != null && (r = p.right) != null) {
//将r(p的右子树)的左子树编程p的右子树
if ((rl = p.right = r.left) != null)
//修改父节点引用,rl是r(p的右子树)的左子树
rl.parent = p;
// 将r(p的右子树)的父节点变成p的父节点(左旋过程,将右子树变成自己的父节点)
if ((pp = r.parent = p.parent) == null)
//如果p节点的父节点为null,证明p是根节点(子树的根节点)
//将r变成根节点(子树的根节点),并变成黑色(平衡)
(root = r).red = false;
//如果存在父节点且p是该节点的左子树
else if (pp.left == p)
//将r(p的右子树)变成该节点的左子树
pp.left = r;
//如果存在父节点且p节点是该节点的右子树
else
//将r(p的右子树)变成该节点的右子树
pp.right = r;
//将r(p的左子树)变成p(左旋中,将左子树变成自己的父节点)
r.left = p;
//r变成p的父节点
p.parent = r;
}
return root;
}
看一下图示。
- p没有父节点
- p有父节点
4.3、右旋
/**
- 红黑树右旋
**/
static <K,V> TreeNode<K,V> rotateRight(TreeNode<K,V> root,
TreeNode<K,V> p) {
TreeNode<K,V> l, pp, lr;
//p不为null且p的左子树不为null
if (p != null && (l = p.left) != null) {
//将l(p的左子树)的右子树变成p的左子树
if ((lr = p.left = l.right) != null)
lr.parent = p;
//将l(p的右子树)的父节点变成p的父节点(右旋过程,将左子树变成自己的父节点)
if ((pp = l.parent = p.parent) == null)
(root = l).red = false;
//如果存在父节点且p是该节点的右子树
else if (pp.right == p)
pp.right = l;
//如果存在父节点且p是该节点的左子树
else
pp.left = l;
//将l(p的右子树)变成p(右旋中,将右子树变成自己的父节点)
l.right = p;
p.parent = l;
}
return root;
}
图示如下:
- p没有父节点(可以理解为p是根节点)
- p有父节点
4.3、树化
treeify,意即树化。
前面提到了,当哈希桶中的链表长度超过阈值(默认8)的时候,就会对链表进行树化。
/**
-
红黑树化
-
@return 树的根节点
*/
final void treeify(Node<K,V>[] tab) {
TreeNode<K,V> root = null;
//循环整理
for (TreeNode<K,V> x = this, next; x != null; x = next) {
//取出下一个链表节点
next = (TreeNode<K,V>)x.next;
//将x节点的左右节点设置为null
x.left = x.right = null;
//判断当前红黑树是否有根节点
if (root == null) {
//如果没有根节点
//当前节点的父节点设置为null
x.parent = null;
//设置颜色为黑色(根节点为黑色)
x.red = false;
//将x节点设置为根节点
root = x;
}
//当前红黑树存在根节点
else {
//获取x节点的key
K k = x.key;
//获取x节点的hash
int h = x.hash;
//key的class
Class<?> kc = null;
//从根节点遍历,将x节点插入到红黑树中
for (TreeNode<K,V> p = root;😉 {
//定义dir(方向),ph(节点hash)
int dir, ph;
//取出p节点的key
K pk = p.key;
//当p节点的hash大于x节点的hash时
if ((ph = p.hash) > h)
//左侧
dir = -1;
else if (ph < h)
//右侧
dir = 1;
//如果上面的if分支没走,则证明两个节点key的hash值相等,需要通过其他方式进行比较
//如果当前节点(x)的key的类实现了comparable接口,且当前循环节点§是相同Class的实例
//那么就通过comparable进行比较
else if ((kc == null &&
(kc = comparableClassFor(k)) == null) ||
(dir = compareComparables(kc, k, pk)) == 0)
//若还是相等,就通过tieBreakOrder比较
dir = tieBreakOrder(k, pk);
//先缓存p节点
TreeNode<K,V> xp = p;
//根据dir方向,来选择在左侧还是右侧插入
//并判断是否为null
if ((p = (dir <= 0) ? p.left : p.right) == null) {
//选择的左/右子树为null
//将原来的p节点(现xp)设置为x的父节点
x.parent = xp;
//如果dir 小于等于0
//将x节点放置在原p(现xp)节点的左侧
if (dir <= 0)
xp.left = x;
//如果dir 大于0
//将x节点放置在原p(现xp)节点的右侧
xp.right = x;
//调用balanceInsertion进行插入平衡
root = balanceInsertion(root, x);
break;
}
}
}
}
//确保哈希桶指定位置存储的节点是红黑树的根节点
moveRootToFront(tab, root);
}
/**
- 确保哈希桶指定位置存储的节点是红黑树的根节点
*/
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;
TreeNode<K,V> first = (TreeNode<K,V>)tab[index];
//如果不是红黑树的根节点
if (root != first) {
Node<K,V> rn;
//指向红黑树的根节点
tab[index] = root;
TreeNode<K,V> rp = root.prev;
//整理节点顺序
if ((rn = root.next) != null)
((TreeNode<K,V>)rn).prev = rp;
if (rp != null)
rp.next = rn;
if (first != null)
first.prev = root;
root.next = first;
root.prev = null;
}
//递归做一个恒定校验
assert checkInvariants(root);
}
}
图例如下:
4.4、插入平衡
红黑树插入节点后,需要保持平衡。
balanceInsertion就是在保持红黑树插入节点后的平衡。
保持平衡的方式是旋转和变色。
/**
- 插入平衡
*/
static <K,V> TreeNode<K,V> balanceInsertion(TreeNode<K,V> root,
TreeNode<K,V> x) {
//将x节点设为红色(新插入节点一开始为红色)
x.red = true;
//一个没有边界的循环(需要内部跳出)
for (TreeNode<K,V> xp, xpp, xppl, xppr;😉 {
//取出x的父节点并判断是否为null
if ((xp = x.parent) == null) {
//x没有父节点
x.red = false;//变色(黑色)
return x;//x为根节点发那会
}
//如果x存在父节点且x的父节点为黑色或x的父父节点不存在
else if (!xp.red || (xpp = xp.parent) == null)
//返回root
return root;
//如果x的父节点是父父节点的左孩子
if (xp == (xppl = xpp.left)) {
//父父节点的右孩子不为null且为红色
if ((xppr = xpp.right) != null && xppr.red) {
xppr.red = false;//变色(黑)
xp.red = false;//变色(黑)
xpp.red = true;//变色(红)
x = xpp;
}
else {
//x是父节点的右孩子
if (x == xp.right) {
//左旋
root = rotateLeft(root, x = xp);
//处理x的父父节点
xpp = (xp = x.parent) == null ? null : xp.parent;
}
//x的父节点存在
if (xp != null) {
xp.red = false;//变色
//x的父父节点存在
if (xpp != null) {
xpp.red = true;//变色
//右旋
root = rotateRight(root, xpp);
}
}
}
}
//如果x的父节点是父父节点的右孩子
else {
//x的父父节点的左孩子存在且为红色
if (xppl != null && xppl.red) {
xppl.red = false;//变色(黑)
xp.red = false;//变色(黑)
xpp.red = true;//变色(红)
x = xpp;
}
else {
//如果x是父节点的左孩子
if (x == xp.left) {
//右旋
root = rotateRight(root, x = xp);
//处理x的父父节点
xpp = (xp = x.parent) == null ? null : xp.parent;
}
//如果x的父节点存在
if (xp != null) {
xp.red = false;//变色(黑)
//如果x的父父节点存在
if (xpp != null) {
xpp.red = true;//变色(红)
//左旋
root = rotateLeft(root, xpp);
}
}
}
}
}
}
图例如下:
- 假如有如下一个链表,里面的数字代表hash值(先不考虑hash分布)
- 然后按照链表顺序取出节点进行红黑树插入,以及插入后平衡操作(左旋右旋/变色)
4.5、反树化
当链表的长度小于6时反树化,即红黑树退化成链表。
/**
- 红黑树链表化
*/
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) {
//构造一个普通链表节点
Node<K,V> p = map.replacementNode(q, null);
//维护顺序
if (tl == null)
hd = p;
else
tl.next = p;
tl = p;
}
return hd;
}
4.6、查找
对应链表的节点查找,在链表树化后,节点的查找就是红黑树实现的。查找的逻辑还是比较清晰的,因为红黑树是自平衡二叉查找树,节点左子树都比自己小,右子树都比自己大,所以根据给定的hash,可以确定从左子树还是右子树查找,然后进行循环。
/**
- 红黑树节点查找的入口方法
*/
final TreeNode<K,V> getTreeNode(int h, Object k) {
return ((parent != null) ? root() : this).find(h, k, null);
}
/**
- 根据给定的hash和key,从红黑树的根节点开始进行查找
*/
final TreeNode<K,V> find(int h, Object k, Class<?> kc) {
TreeNode<K,V> p = this;
do {
int ph, dir; K pk;
//取出左子树和右子树,根据hash和key进行查找
TreeNode<K,V> pl = p.left, pr = p.right, q;
//根据hash大小决定取左子树还是右子树
if ((ph = p.hash) > h)
p = pl;
else if (ph < h)
p = pr;
//如果在节点相等,就返回
else if ((pk = p.key) == k || (k != null && k.equals(pk)))
return p;
else if (pl == null)
p = pr;
else if (pr == null)
p = pl;
else if ((kc != null ||
(kc = comparableClassFor(k)) != null) &&
(dir = compareComparables(kc, k, pk)) != 0)
p = (dir < 0) ? pl : pr;
else if ((q = pr.find(h, k, kc)) != null)
return q;
else
p = pl;
} while (p != null);
return null;
}
4.7、删除节点
删除节点的操作还是比较麻烦,因为删除之后需要平衡红黑树。
/**
-
移除给定节点, 调用该方法时要确保节点存在.
-
因为无法交换存在叶子节点的内部节点内容,所以这会比典型的红黑树节点删除来得复杂
-
遍历过程中"next"指针指向的继任节点是可访问的,所以我们交换了树的连接.
-
如果当前树节点太少,则将二叉树替换成简单形式
-
(2-6节点测试触发,取决于树的结构)
*/
final void removeTreeNode(HashMap<K,V> map, Node<K,V>[] tab,
boolean movable) {
int n;
//判断哈希桶
if (tab == null || (n = tab.length) == 0)
return;
//下标
int index = (n - 1) & hash;
//取出指定下标的根节点
TreeNode<K,V> first = (TreeNode<K,V>)tab[index], root = first, rl;
//继任节点和前置节点
TreeNode<K,V> succ = (TreeNode<K,V>)next, pred = prev;
//前置节点不存在,则证明要移除的节点是根节点
if (pred == null)
//将继任节点往前移
tab[index] = first = succ;
else
//前置节点存在,则将继任节点连接到前置节点(移除本节点)
pred.next = succ;
//判断继任节点是否存在
if (succ != null)
//存在的话,修改前置引用
succ.prev = pred;
//这个时候first为null,则表示哈希桶指定位置可能只有一个节点
if (first == null)
//返回
return;
//获取根节点
if (root.parent != null)
root = root.root();
//根节点不存在或者根节点的左子树/右子树不存在或者左左子树不存在
//该判断是作为链表化的阈值
if (root == null || root.right == null ||
(rl = root.left) == null || rl.left == null) {
//红黑树太小,进行链表化
tab[index] = first.untreeify(map); // too small
return;
}
//取得要移除的节点,左子树,右子树
TreeNode<K,V> p = this, pl = left, pr = right, replacement;
//左右子树同时存在
if (pl != null && pr != null) {
TreeNode<K,V> s = pr, sl;
//循环查找继任节点
while ((sl = s.left) != null) // find successor
s = sl;
//交换p和s的颜色
boolean c = s.red; s.red = p.red; p.red = c; // swap colors
TreeNode<K,V> sr = s.right;
TreeNode<K,V> pp = p.parent;
//相等则证明p是s的直接父节点(只有一个层级)
if (s == pr) { // p was s’s direct parent
//交换位置
p.parent = s;
s.right = p;
}
//如果是多个层级
else {
//取出s的父节点
TreeNode<K,V> sp = s.parent;
//下面操作仍然是交换p和s的位置
if ((p.parent = sp) != null) {
if (s == sp.left)
sp.left = p;
else
sp.right = p;
}
if ((s.right = pr) != null)
pr.parent = s;
}
//清空p的右子树引用
p.left = null;
//调整相关引用
if ((p.right = sr) != null)
sr.parent = p;
if ((s.left = pl) != null)
pl.parent = s;
if ((s.parent = pp) == null)
root = s;
else if (p == pp.left)
pp.left = s;
else
pp.right = s;
//确定替换节点
if (sr != null)
replacement = sr;
else
replacement = p;
}
//只有左子树存在
else if (pl != null)
replacement = pl;
//只有右子树存在
else if (pr != null)
replacement = pr;
//左右子树都不存在
else
replacement = p;
//判断替换的节点是不是自身
if (replacement != p) {
//不是自身的话,则执行相关替换操作
TreeNode<K,V> pp = replacement.parent = p.parent;
if (pp == null)
root = replacement;
else if (p == pp.left)
pp.left = replacement;
else
pp.right = replacement;
p.left = p.right = p.parent = null;
}
//判断p的颜色
//如果p是红色节点,则将根节点赋值给r
//如果p是黑色节点,则进行删除平衡(类似于插入平衡)
//这里的r要存储红黑树的根节点
TreeNode<K,V> r = p.red ? root : balanceDeletion(root, replacement);
//如果替换节点是自身的话
if (replacement == p) { // detach
//进行分离操作
TreeNode<K,V> pp = p.parent;
p.parent = null;
if (pp != null) {
if (p == pp.left)
pp.left = null;
else if (p == pp.right)
pp.right = null;
}
}
if (movable)
//确保哈希桶下标指定位置存储的是红黑树根节点
moveRootToFront(tab, r);
}
- 无参构造方法:
/**
- 所有参数使用默认值
*/
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
- HashMap(int initialCapacity):指定默认装载因子
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
- HashMap(int initialCapacity, float loadFactor):判断传入的初始容量和装载因子是否合法,并计算扩容门槛,扩容门槛为传入的初始容量往上取最近的2的n次方
public HashMap(int initialCapacity, float loadFactor) {
// 检查传入的初始容量是否合法
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
// 检查装载因子是否合法
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
this.loadFactor = loadFactor;
// 计算扩容门槛
this.threshold = tableSizeFor(initialCapacity);
}
static final int tableSizeFor(int cap) {
// 扩容门槛为传入的初始容量往上取最近的2的n次方
int n = cap - 1;
n |= n >>> 1;
n |= n >>> 2;
n |= n >>> 4;
n |= n >>> 8;
n |= n >>> 16;
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}
HashMap插入的流程图如下:
public V put(K key, V value) {
//调用hash(key)计算出key的hash值
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;
// 初始化桶数组 table,table 被延迟到插入新数据时再进行初始化
if ((tab = table) == null || (n = tab.length) == 0)
// 调用resize()初始化
n = (tab = resize()).length;
// (n - 1) & hash 计算元素在哪个桶中
// 如果这个桶中还没有元素,则把这个元素放在桶中的第一个位置
if ((p = tab[i = (n - 1) & hash]) == null)
//新建一个节点放在桶中
tab[i] = newNode(hash, key, value, null);
else {
//如果桶中已经有元素存在了
Node<K,V> e; K k;
// 如果桶中第一个元素的key与待插入元素的key相同,保存到e中用于后续修改value值
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
else if (p instanceof TreeNode)
// 如果第一个元素是树节点,则调用树节点的putTreeVal插入元素
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
// 遍历这个桶对应的链表,binCount用于存储链表中元素的个数
for (int binCount = 0; ; ++binCount) {
// 如果链表遍历完了都没有找到相同key的元素,说明该key对应的元素不存在,则在链表最后插入一个新节点
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
// 如果插入新节点后链表长度大于8,则判断是否需要树化,因为第一个元素没有加到binCount中,所以这里-1
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
// 如果待插入的key在链表中找到了,则退出循环
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
// 如果找到了对应key的元素
if (e != null) { // existing mapping for key
// 记录下旧值
V oldValue = e.value;
// 判断是否需要替换旧值
if (!onlyIfAbsent || oldValue == null)
// 替换旧值为新值
e.value = value;
afterNodeAccess(e);
// 返回旧值
return oldValue;
}
}
// 到这里了说明没有找到元素
// 修改次数加1
++modCount;
// 元素数量加1,判断是否需要扩容
if (++size > threshold)
// 扩容
resize();
afterNodeInsertion(evict);
return null;
}
插入:
-
1、首先进行哈希值的扰动,获取一个新的哈希值。
-
2、判断tab是否位空或者长度为0,如果是则进行扩容操作
-
3、根据哈希值计算下标,如果对应小标正好没有存放数据,则直接插入即可,否则需要覆盖。
-
4、判断tab[i]是否为树节点,否则向链表中插入数据,是则向树中插入节点。
-
5、如果链表中插入节点的时候,链表长度大于等于8,则需要把链表转换为红黑树。
-
6、最后所有元素处理完成后,判断是否超过阈值;threshold,超过则扩容。
-
7、treeifyBin,是一个链表转树的方法,但不是所有的链表长度为8后都会转成树,还需要判断存放key值的数组桶长度是否小于64 (MIN_TREEIFY_CAPACITY)。如果小于则需要扩容,扩容后链表上的数据会被拆分散列的相应的桶节点上,也就把链表长度缩短了。
HashMap是基于数组+链表和红黑树实现的,但用于存放key值得的数组桶的长度是固定的,由初始化决定。
那么,随着数据的插入数量增加以及负载因子的作用下,就需要扩容来存放更多的数据。
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)
// 如果旧容量的两倍小于最大容量并且旧容量大于默认初始容量(16),则容量扩大为两部,扩容门槛也扩大为两倍
newThr = oldThr << 1; // double threshold
} else if (oldThr > 0) // initial capacity was placed in threshold
// 使用非默认构造方法创建的map,第一次插入元素会走到这里
// 如果旧容量为0且旧扩容门槛大于0,则把新容量赋值为旧门槛
newCap = oldThr;
else { // zero initial threshold signifies using defaults
// 调用默认构造方法创建的map,第一次插入元素会走到这里
// 如果旧容量旧扩容门槛都是0,说明还未初始化过,则初始化容量为默认容量,扩容门槛为默认容量*默认装载因子
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int) (DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
if (newThr == 0) {
// 如果新扩容门槛为0,则计算为容量*装载因子,但不能超过最大容量
float ft = (float) newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float) MAXIMUM_CAPACITY ?
(int) ft : Integer.MAX_VALUE);
}
// 赋值扩容门槛为新门槛
最后
自我介绍一下,小编13年上海交大毕业,曾经在小公司待过,也去过华为、OPPO等大厂,18年进入阿里一直到现在。
深知大多数Java工程师,想要提升技能,往往是自己摸索成长,自己不成体系的自学效果低效漫长且无助。
因此收集整理了一份《2024年Java开发全套学习资料》,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友,同时减轻大家的负担。
既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,基本涵盖了95%以上Java开发知识点,不论你是刚入门Android开发的新手,还是希望在技术上不断提升的资深开发者,这些资料都将为你打开新的学习之门!
如果你觉得这些内容对你有帮助,需要这份全套学习资料的朋友可以戳我获取!!
由于文件比较大,这里只是将部分目录截图出来,每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频,并且会持续更新!
= (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)
// 如果旧容量的两倍小于最大容量并且旧容量大于默认初始容量(16),则容量扩大为两部,扩容门槛也扩大为两倍
newThr = oldThr << 1; // double threshold
} else if (oldThr > 0) // initial capacity was placed in threshold
// 使用非默认构造方法创建的map,第一次插入元素会走到这里
// 如果旧容量为0且旧扩容门槛大于0,则把新容量赋值为旧门槛
newCap = oldThr;
else { // zero initial threshold signifies using defaults
// 调用默认构造方法创建的map,第一次插入元素会走到这里
// 如果旧容量旧扩容门槛都是0,说明还未初始化过,则初始化容量为默认容量,扩容门槛为默认容量*默认装载因子
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int) (DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
if (newThr == 0) {
// 如果新扩容门槛为0,则计算为容量*装载因子,但不能超过最大容量
float ft = (float) newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float) MAXIMUM_CAPACITY ?
(int) ft : Integer.MAX_VALUE);
}
// 赋值扩容门槛为新门槛
最后
自我介绍一下,小编13年上海交大毕业,曾经在小公司待过,也去过华为、OPPO等大厂,18年进入阿里一直到现在。
深知大多数Java工程师,想要提升技能,往往是自己摸索成长,自己不成体系的自学效果低效漫长且无助。
因此收集整理了一份《2024年Java开发全套学习资料》,初衷也很简单,就是希望能够帮助到想自学提升又不知道该从何学起的朋友,同时减轻大家的负担。
[外链图片转存中…(img-obfMK5Wx-1715312678777)]
[外链图片转存中…(img-QLSZ9jq4-1715312678777)]
[外链图片转存中…(img-QZPiyUdc-1715312678778)]
既有适合小白学习的零基础资料,也有适合3年以上经验的小伙伴深入学习提升的进阶课程,基本涵盖了95%以上Java开发知识点,不论你是刚入门Android开发的新手,还是希望在技术上不断提升的资深开发者,这些资料都将为你打开新的学习之门!
如果你觉得这些内容对你有帮助,需要这份全套学习资料的朋友可以戳我获取!!
由于文件比较大,这里只是将部分目录截图出来,每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频,并且会持续更新!