HashMap源码阅读笔记，2024年最新计算机it行业

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);

}

5、HashMap构造方法

---

• 无参构造方法：

/**

• 所有参数使用默认值

*/

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;

}

6、插入

---

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）。如果小于则需要扩容，扩容后链表上的数据会被拆分散列的相应的桶节点上，也就把链表长度缩短了。

7、扩容

---

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);

}

// 赋值扩容门槛为新门槛

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;

// 如果桶中第一个元素不为空，赋值给e

if ((e = oldTab[j]) != null) {

// 清空旧桶，便于GC回收

oldTab[j] = null;

// 如果这个桶中只有一个元素，则计算它在新桶中的位置并把它搬移到新桶中

// 因为每次都扩容两倍，所以这里的第一个元素搬移到新桶的时候新桶肯定还没有元素

if (e.next == null)

newTab[e.hash & (newCap - 1)] = e;

else if (e instanceof TreeNode)

// 如果第一个元素是树节点，则把这颗树打散成两颗树插入到新桶中去

((TreeNode<K, V>) e).split(this, newTab, j, oldCap);

else { // preserve order

// 如果这个链表不止一个元素且不是一颗树

// 则分化成两个链表插入到新的桶中去

// 比如，假如原来容量为4，3、7、11、15这四个元素都在三号桶中

// 现在扩容到8，则3和11还是在三号桶，7和15要搬移到七号桶中去

// 也就是分化成了两个链表

Node<K, V> loHead = null, loTail = null;

Node<K, V> hiHead = null, hiTail = null;

Node<K, V> next;

do {

next = e.next;

// (e.hash & oldCap) == 0的元素放在低位链表中

// 比如，3 & 4 == 0

if ((e.hash & oldCap) == 0) {

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数同学面临毕业设计项目选题时，很多人都会感到无从下手，尤其是对于计算机专业的学生来说，选择一个合适的题目尤为重要。因为毕业设计不仅是我们在大学四年学习的一个总结，更是展示自己能力的重要机会。

因此收集整理了一份《2024年计算机毕业设计项目大全》，初衷也很简单，就是希望能够帮助提高效率，同时减轻大家的负担。

既有Java、Web、PHP、也有C、小程序、Python等项目供你选择，真正体系化！

由于项目比较多，这里只是将部分目录截图出来，每个节点里面都包含素材文档、项目源码、讲解视频

如果你觉得这些内容对你有帮助，可以添加VX：vip1024c （备注项目大全获取）

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;

// 如果桶中第一个元素不为空，赋值给e

if ((e = oldTab[j]) != null) {

// 清空旧桶，便于GC回收

oldTab[j] = null;

// 如果这个桶中只有一个元素，则计算它在新桶中的位置并把它搬移到新桶中

// 因为每次都扩容两倍，所以这里的第一个元素搬移到新桶的时候新桶肯定还没有元素

if (e.next == null)

newTab[e.hash & (newCap - 1)] = e;

else if (e instanceof TreeNode)

// 如果第一个元素是树节点，则把这颗树打散成两颗树插入到新桶中去

((TreeNode<K, V>) e).split(this, newTab, j, oldCap);

else { // preserve order

// 如果这个链表不止一个元素且不是一颗树

// 则分化成两个链表插入到新的桶中去

// 比如，假如原来容量为4，3、7、11、15这四个元素都在三号桶中

// 现在扩容到8，则3和11还是在三号桶，7和15要搬移到七号桶中去

// 也就是分化成了两个链表

Node<K, V> loHead = null, loTail = null;

Node<K, V> hiHead = null, hiTail = null;

Node<K, V> next;

do {

next = e.next;

// (e.hash & oldCap) == 0的元素放在低位链表中

// 比如，3 & 4 == 0

if ((e.hash & oldCap) == 0) {

自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。

深知大多数同学面临毕业设计项目选题时，很多人都会感到无从下手，尤其是对于计算机专业的学生来说，选择一个合适的题目尤为重要。因为毕业设计不仅是我们在大学四年学习的一个总结，更是展示自己能力的重要机会。

因此收集整理了一份《2024年计算机毕业设计项目大全》，初衷也很简单，就是希望能够帮助提高效率，同时减轻大家的负担。
[外链图片转存中…(img-h8zCTEJ5-1712520318001)]
[外链图片转存中…(img-BxOumGK7-1712520318002)]
[外链图片转存中…(img-xUP2j8Rk-1712520318003)]

既有Java、Web、PHP、也有C、小程序、Python等项目供你选择，真正体系化！

由于项目比较多，这里只是将部分目录截图出来，每个节点里面都包含素材文档、项目源码、讲解视频

如果你觉得这些内容对你有帮助，可以添加VX：vip1024c （备注项目大全获取）
[外链图片转存中…(img-CQKupXnO-1712520318003)]