HashMap 基本原理以及底层源码分析
1.HashMap 的存储结构：
HashMap 是由数组加上链式结构（链表）以及红黑树组成。在 JDK 1.8 增加实现了红黑树的结构。（根据存储数据量的大小会动态的变化存储结构）。
源码实现：
/**
* 基本哈希箱节点，用于大多数条目。 （有
* 关TreeNode子类的信息，请参见下文；有关EntryEntry子类的信息，请参见LinkedHashMap。）
* Node: 数据节点
*/
static class Node<K,V> implements Map.Entry<K,V> {
/**
* hash值 对key的hashcode值进行hash运算后得到的值，存储在Entry，避免重复计算
* */
final int hash;
/**
* key 索引
* */
final K key;
/**
* data 数据域
* */
V value;
/**
* 下一个 node 节点
* */
Node<K,V> next;
/**
* 构造函数
*/
Node(int hash, K key, V value, Node<K,V> next) {
this.hash = hash;
this.key = key;
this.value = value;
this.next = next;
}
/**
* 获取 key 值
* */
public final K getKey() { return key; }
/**
* 获取 value 值
* */
public final V getValue() { return value; }
/**
* key = value
* */
public final String toString() { return key + "=" + value; }
/**
* hashCode 的存在主要是用于查找的快捷性，hashCode是用来在散列存储结构中确定对象的存储地址的；
* 注意：两个对象的hashCode相同，并不一定表示两个对象就相同
*
* 1.hashcode是用来查找的 例如内存中有这样的位置
* 0 1 2 3 4 5 6 7
* 而我有个类，这个类有个字段叫ID,我要把这个类存放在以上8个位置之一，如果不用hashcode而任意存放，那么当查找
* 时就需要到这八个位置里挨个去找，或者用二分法一类的算法。
* 但如果用hashcode那就会使效率提高很多。
* 我们这个类中有个字段叫ID,那么我们就定义我们的hashcode为ID％8，然后把我们的类存放在取得得余数那个位置。比
* 如我们的ID为9，9除8的余数为1，那么我们就把该类存在1这个位置，如果ID是13，求得的余数是5，那么我们就把该类
* 放在5这个位置。这样，以后在查找该类时就可以通过ID除 8求余数直接找到存放的位置了。
*
* 2.但是如果两个类有相同的hashcode怎么办那（我们假设上面的类的ID不是唯一的），例如9除以8和17除以8的余数都 * 是1，那么这是不是合法的，回答是：可以这样。那么如何判断呢？在这个时候就需要定义 equals了。
* 也就是说，我们先通过 hashcode来判断两个类是否存放某个桶里，但这个桶里可能有很多类，那么我们就需要再通过 * equals 来在这个桶里找到我们要的类。
* 那么。重写了equals()，为什么还要重写hashCode()呢？
* 想想，你要在一个桶里找东西，你必须先要找到这个桶啊，你不通过重写hashcode()来找到桶，光重写equals()有什 * 么用啊
* */
public final int hashCode() {
return Objects.hashCode(key) ^ Objects.hashCode(value);
}
/**
* 设置新的value值，会返回旧的数据
* */
public final V setValue(V newValue) {
V oldValue = value;
value = newValue;
return oldValue;
}
/**
* 判断对象是否相等
* */
public final boolean equals(Object o) {
if (o == this) {
return true;
}
if (o instanceof Map.Entry) {
Map.Entry<?,?> e = (Map.Entry<?,?>)o;
if (Objects.equals(key, e.getKey()) &&
Objects.equals(value, e.getValue())) {
return true;
}
}
return false;
}
}
使用到的一些基本参数：
/**
* 默认初始容量-必须为 2 的幂。
*/
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
/**
* 最大容量，如果两个构造函数都使用参数隐式指定了更高的值，则使用该容量。
* 最大 1073741824
*/
static final int MAXIMUM_CAPACITY = 1 << 30;
/**
* 在构造函数中未指定时使用的负载系数。
* 加载因子 默认 0.75
*/
static final float DEFAULT_LOAD_FACTOR = 0.75f;
/**
* 使用树而不是列表列出 bin 的 bin 计数阈值。
* 当将元素添加到至少具有这么多节点的bin中时，bin会转换为树。
* 该值必须大于2，并且至少应为8，才能与删除树的假设有关，即收缩时转换回原始分类箱。
* 当桶中元素个数超过这个值时需要使用红黑树节点替换链表节点，以便与优化速度
*
* 也就是当链表的长度到达8的时候，转化为树形结构
*
*/
static final int TREEIFY_THRESHOLD = 8;
/**
* 在调整大小操作期间用于取消树状化（拆分的）箱的箱计数阈值。
* 应小于TREEIFY_THRESHOLD，并且最多为6以与移除下的收缩检测相啮合。
* 当扩容时，桶中元素个数小于这个值 就会把树形的桶元素 还原（切分）为链表结构
* 由树化转换为链式结构
*/
static final int UNTREEIFY_THRESHOLD = 6;
/**
* 可将其分类为树的最小容量。
* （否则，如果bin中的节点过多，则将调整表的大小。）应至少为4 TREEIFY_THRESHOLD以避免调整大小和树化阈值之间的冲突。
* 当哈希表中的容量大于这个值时，表中的桶才能进行树形化
* 否则桶内元素太多时会扩容，而不是树形化
* 为了避免进行扩容、树形化选择的冲突，这个值不能小于 4 * TREEIFY_THRESHOLD （256）
*
*/
static final int MIN_TREEIFY_CAPACITY = 64;
基本结构参数定义：
/**
* 该表在首次使用时初始化，并根据需要调整大小。 分配后，长度始终是2的幂。
* （在某些操作中，我们还允许长度为零，以允许使用当前不需要的引导机制。）
* 主要作用：保存 Node结点的数组结构。
*/
transient Node<K,V>[] table;
/**
* 保存缓存的entrySet（）。
* 注意，AbstractMap 字段用于 keySet（）和 values（）。
* 主要作用： Node结点构成的 Set数据结构
*/
transient Set<Map.Entry<K,V>> entrySet;
/**
* 此映射中包含的键-值映射数。
*/
transient int size;
/**
* 对该HashMap进行结构修改的次数
* 结构修改：
* 是指更改 HashMap中的映射次数或以其他方式修改其内部结构（例如，重新哈希）的修改。
* 此字段用于使 HashMap的 Collection-view 上的迭代器快速失败。
* （请参见ConcurrentModificationException）。
*/
transient int modCount;
/**
* 下一个要调整大小的 大小值（容量负载因子）。
* threshold 表示当 HashMap的size 大于 threshold 时会执行 resize 操作。
*
* 通常： threshold = loadFactor * capacity
* @serial
*/
// (序列化后，javadoc描述为true。
//此外，如果尚未分配表阵列，
//则此字段将保留初始阵列容量，
//或者为零，表示DEFAULT_INITIAL_CAPACITY。）
int threshold;
/**
* 哈希表的负载因子。
*
* @serial
*/
final float loadFactor;
2.初始化 HashMap
默认给出了四种初始化的构造函数
初始化的时候可以指定hashMap的初始容量以及负载因子。jdk1.7在调用构造函数初始化的时候就进行了计算，但是1.8是在进行第一次put操作的时候进行初始化。而resize()方法在一定程度上承担了初始化以及扩容的任务。（初始化也相当于是进行了扩容任务）
/**
* 构造一个具有指定 初始容量 和 负载因子 的空Map
*
* @param initialCapacity the initial capacity 初始化空间
* @param loadFactor the load factor 负载因子
* @throws IllegalArgumentException if the initial capacity is negative or the load factor is nonpositive
*/
public HashMap(int initialCapacity, float loadFactor) {
/* 如果初始容量小于0: 异常：初始容量不合法 */
if (initialCapacity < 0) {
throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity);
}
//如果初始化的容量大于最大的容量：1 << 30 ，初始化容量变为最大容量
if (initialCapacity > MAXIMUM_CAPACITY) {
initialCapacity = MAXIMUM_CAPACITY;
}
//加载因子小于等于0。或者未传入加载因子。 抛出异常：加载因子错误
if (loadFactor <= 0 || Float.isNaN(loadFactor)) {
throw new IllegalArgumentException("Illegal load factor: " + loadFactor);
}
this.loadFactor = loadFactor;
/*初始化参数 threshold */
this.threshold = tableSizeFor(initialCapacity);
}
- threshold 容量阈值：下一次需要调整map大小的阈值。这个计算方很有意思：
如果给定容量是 3，最接近的值就是 22 = 4 如果给定容量是 5，最接近的值就是 23 = 8 如果给定容量是 13，最接近的值就是 24 = 16 由此可以得出规律：该算法的作用就是把最高位 1 后面的数值全部变成 1，最后将计算出来的结果 + 1。
/**
* 对于给定的目标容量，将传进来的参数转变为2的n次方的数值
* cap 当前容量 通过运算，返回一个 cap 二进制位都位一的一个 2的n次方数。
* MAXIMUM_CAPACITY 为最大的上限
* 计算原理：
* 5： 0000 0000 0000 0101
* 7： 0000 0000 0000 0111 step 1: 对一个二进制数依次向右移位，然后与原值取或。对于一个数字的二进制，从第一个不为0的位开始，把后面的所有位都设置成1。
* 8： 0000 0000 0000 1000 step 2: 7 + 1 -> 8 得到大于 0000 0000 0000 0101 的第一哥个 2 的幂
*
* 但是上面的操作对于 2，4，8 这类本就是2的n次方来说不合适，所以实现了： cap - 1 操作, 这样以来就会得到最小的2的次方（本身）
*
*/
static final int tableSizeFor(int cap) {
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 ，它具有指定的初始容量和默认负载因子（0.75）。
* 如果我们指定 capacity 的值， 一般会采用大于该数值的第一个2的幂作为初始化容量
* @param initialCapacity the initial capacity.
* @throws IllegalArgumentException if the initial capacity is negative.
*/
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
/**
* 构造一个空的<tt> HashMap <tt>，
* 它具有默认的初始容量（16）和默认的负载系数（0.75）。
* 不指定初始化大小，则默认大小为 16 和负载因子 0.75
*/
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; //所有其他字段均默认
}
/**
* 构造一个新的 HashMap，
* 其映射与指定的 Map 相同。
* HashMap 是使用默认负载因子（0.75）和足以将映射保存在指定的 Map 中的初始容量创建的。
*
* @param m 要在其map中放置其映射的map
* @throws NullPointerException if the specified map is null
*/
public HashMap(Map<? extends K, ? extends V> m) {
/*加载因子为默认 0.75*/
this.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m, false);
}
3. HashMap 的put方法：
- 如果 table 为空，调用resize()方法进行第一次扩容操作，也就是所谓的初始化HashMap。为HashMap分配初始化容量。
- 桶中不存在任何节点。创建新的节点， Node<K,V>
- 存在相同的节点 p.hash == hash 并且 (k = p.key) == key 这就表示发生了hash冲突，新的节点和旧的节点相同。更新旧结点。
- 拉链法：循环遍历链表，找到节点对应的地址，判断是否需要更新数据节点。或者创建节点判断是否达到链表长度 8 （头结点 + 其他 7 个结点）。判断是否需要树化结构。
- 扩容机制： 如果加入元素后的长度 大于临界值 则调用resize方法
/**
* 将指定值与该映射中的指定键相关联。如果该映射先前包含该键的映射，则将替换旧值。
*
* @param key 指定值将与之关联的键
* @param value 与指定键关联的值
* @return the previous value associated with <tt>key</tt>, or
* <tt>null</tt> if there was no mapping for <tt>key</tt>.
* (A <tt>null</tt> return can also indicate that the map
* previously associated <tt>null</tt> with <tt>key</tt>.)
*/
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
/**
* Implements Map.put and related methods.
*
* @param hash hash for key key的hash值
* @param key the key 索引key
* @param value the value to put 值
* @param onlyIfAbsent 如果为true，请不要更改现有值
* @param evict 如果为false，则表处于创建模式。
* @return 如果原来存在值，返回先前的值；如果没有，则为null
*/
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为空，进行初始化
if ((tab = table) == null || (n = tab.length) == 0) {
//这里初始化的长度为16： resize() 扩容。
n = (tab = resize()).length;
}
// (n -1) & hash : & 除法散列法进行散列计算, 根据hash值获取到节点为空，初始化一个新的数据节点
if ((p = tab[i = (n - 1) & hash]) == null) {
//初始化数据结点
tab[i] = newNode(hash, key, value, null);
}
//根据hash值计算寻到 p结点
else {
//新结点
Node<K,V> e;
// 索引
K k;
//p.hash == hash: p结点的hash值与新数据的hash相等并且 (k = p.key) == key key索引相同
//或者 key 不空且相等， 简单来说就是e 和 p 的hash相同键相同，直接使用e覆盖原来的p结点
if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) {
// e 结点 == p 结点 （地址相同）
e = p;
}
/*表示 hash值相同但是，key不相等*/
// 如果是树形结点，进行插入处理。 红黑树
else if (p instanceof TreeNode) {
e = ((TreeNode<K,V>) p).putTreeVal(this, tab, hash, key, value);
}
// 不是树形结构， 就属于链式结构，新建一个链式结点
else {
//统计链式中结点的长度，大于 8 转化为树形
for (int binCount = 0; ; ++binCount) {
// e = p.next 表示 p 结点指向的下一个结点。每一次都是先把下一个结点赋值给e结点，相当于遍历结点
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
// 第一个结点是 -1 ，加上头结点，链表的长度需要小于 阈值 8。 当超过8个结点后，链式结构会转化为树形结构
if (binCount >= TREEIFY_THRESHOLD - 1) {
//链式转化为树形
treeifyBin(tab, hash);
}
break;
}
//在结点遍历的过程中，如果有hash值相同的情况，且key值相同，就直接退出循环，把这个找到的结点直接赋值
if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) {
break;
}
//更新结点，每次都指向下一个结点
p = e;
}
}
// 现有键的映射。如果存在映射关系，替换原来的值
if (e != null) {
V oldValue = e.value;
// 判断是否允许覆盖，并且value是否为空
if (!onlyIfAbsent || oldValue == null) {
e.value = value;
}
// 回调以允许LinkedHashMap后置操作
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
//hash表的 大小查过扩容阈值后，进行扩容操作
if (++size > threshold) {
resize();
}
afterNodeInsertion(evict);
return null;
}
核心机制：1. resize() 扩容机制
/**
* 初始化 或 增加表大小。
* 如果为空，则根据字段阈值中保持的初始容量目标进行分配。
* 否则，因为我们使用的是2的幂，所以每个bin中的元素必须保持相同的索引，或者在新表中以2的幂偏移。
*
* 第一种：使用默认构造方法初始化HashMap。从前文可以知道HashMap在一开始初始化的时候会返回一个空的table，并且thershold为0。因此第一次扩容的容量为默认值DEFAULT_INITIAL_CAPACITY也就是16。同时threshold = DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR = 12。
* 第二种：指定初始容量的构造方法初始化HashMap。那么从下面源码可以看到初始容量会等于threshold，接着threshold = 当前的容量（threshold） * DEFAULT_LOAD_FACTOR。
* 第三种：HashMap不是第一次扩容。如果HashMap已经扩容过的话，那么每次table的容量以及threshold量为原有的两倍。
* @return the table
*/
final Node<K,V>[] resize() {
//将当前的table存放到 oldTable
Node<K,V>[] oldTab = table;
//旧table的长度
int oldCap = (oldTab == null) ? 0 : oldTab.length;
//旧table的阈值
int oldThr = threshold;
int newCap, newThr = 0;
//1.旧table已初始化过
if (oldCap > 0) {
//如果老容量大于最大容量，以达到最大容量
if (oldCap >= MAXIMUM_CAPACITY) {
//阈值等于Int类型的最大值 2^(30) - 1
threshold = Integer.MAX_VALUE;
//无法扩容，返回旧表
return oldTab;
}
//1.将旧值容量进行扩容（使用向左唯一一位（旧容量乘以2））
//2.若扩容之后的容量满足小于最大容量并且旧容量值大于小于默认的容量（16）新的阈值则为旧阈值扩大一倍（必须满足这两个条件）
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY) {
//新阈值为旧阈值的两倍
newThr = oldThr << 1;
}
}
// 初始容量已设置为阈值
//若没有经历过初始化，并且在使用时通过构造函数指定了initialCapacity, 则table大小为threshold, 即大于指定initialCapacity的最小的2的整数次幂（可以通过构造函数得出）
else if (oldThr > 0) {
newCap = oldThr;
} else {
//若没有经历过初始化，并且没有通过构造函数指定initialCapacity，则赋予默认值（数组大小为16，加载因子为0.75）
newCap = DEFAULT_INITIAL_CAPACITY;
//threshold = loadFactor * capacity
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
//上述方法（扩容或者初始化）走完，完成对容量的操作但是并没有指定阈值（正常将容量扩容或者初始化时指定了initialCapacity），计算阈值（最后的容量*加载因子）
if (newThr == 0) {
float ft = (float)newCap * loadFactor;
//最后算出的阈值小于最大容量 并且 最后确定的容量小于 最大容量，则计算出的阈值可以使用，若不满足上述两个条件任何一条则 阈值为Integer最大值
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，根据新的容量重新定义一个数组
//将新建立数组赋值到HashMap成员变量
table = newTab;
//以前的table有数据存在
if (oldTab != null) {
//因为HashMap是数组+链表或者数组+红黑树（根据数组下标找寻到相应链表或者红黑树）遍历原本数组，找到相应的链表或者红黑树进行操作
for (int j = 0; j < oldCap; ++j) {
//临时结点
Node<K,V> e;
//数组[j]有数据，进行后续操作
//将数组[j]下代表的链表或者红黑树的头结点（根节点）赋予 e
if ((e = oldTab[j]) != null) {
//将旧数组[j]处置为空
//我认为这两步的操作就是将原本数组下标处的数据从原本位置挪出，接下来操作此链表即可
oldTab[j] = null;
if (e.next == null) {
//就只有一个头结点（根节点）直接就可按照e.hash & (newCap - 1)的计算法，计算出相应在新table里的位置进行插入
//与put方法里面的操作一致
newTab[e.hash & (newCap - 1)] = e;
} else if (e instanceof TreeNode) {
//如果是红黑树结点
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
} else {
//首先定义五个变量(Tail单词意思是尾部的意思)所以我们可以这么理解
//loHead lo头部 loTail lo尾部
//hiHead hi头部 hiTail hi尾部
// 以上的低位指的是新数组的 0 到 oldCap-1 、高位指定的是oldCap 到 newCap - 1
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
next = e.next;
// 数组的长度一定是2的N次方（例如16），如果hash值和该长度做与运算，那么该hash值可参与计算的有效二进制位就是和长度二进制对等的后几位，如果结果为0，说明hash值中参与计算的对等的二进制位的最高位一定为0.
//因为数组长度的二进制有效最高位是1（例如16对应的二进制是10000），只有*..0**** 和 10000 进行与运算结果才为00000（*..表示不确定的多个二进制位）。又因为定位下标时的取模运算是以hash值和长度减1进行与运算，所以下标 = (*..0**** & 1111) 也= (*..0**** & 11111) 。1111是15的二进制、11111是16*2-1 也就是31的二级制（2倍扩容）。
// 所以该hash值再和新数组的长度取摸的话mod值也不会放生变化，也就是说该元素的在新数组的位置和在老数组的位置是相同的，所以该元素可以放置在低位链表中。
if ((e.hash & oldCap) == 0) {
//这部分很像将一个节点插入链表所需要做的操作(下方图1右侧是只有一个数据时，下列代码最终形成的状态，左侧是多个数据时的最终形成的状态)
if (loTail == null) { // 如果没有尾，说明链表为空
loHead = e; // 链表为空时，头节点指向该元素
} else {
loTail.next = e; // 如果有尾，那么链表不为空，把该元素挂到链表的最后。
}
loTail = e; // 把尾节点设置为当前元素
}
// 如果与运算结果不为0，说明hash值大于老数组长度（例如hash值为17）
// 此时该元素应该放置到新数组的高位位置上
// 例：老数组长度16，那么新数组长度为32，hash为17的应该放置在数组的第17个位置上，也就是下标为16，那么下标为16已经属于高位了，低位是[0-15]，高位是[16-31]
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;
}
在 resize 扩容中最重要的是链表和红黑树的 rehash 操作：
通常我们在进行扩容操作的时候，一般是把长度扩为原来2倍，所以，元素的位置要么是在原位置，要么是在原位置再移动2次幂的位置。
我们在扩充HashMap的时候，只需要看看原来的hash值新增的那个bit是1还是0就好了，是0的话索引没变，是1的话索引变成“原索引+oldCap“，由于新增的1bit是0还是1可以认为是随机的，因此resize的过程，均匀的把之前的冲突的节点分散到新的槽中了
核心机制：2: 分裂树
/**
* 将数形中的节点拆分为较高的树和较低的树，或者如果树现在太小，则取消树化。仅从调整大小调用；
* 也就是切分数，避免数过大化
* @param map the map
* @param tab the table for recording bin heads
* @param index the index of the table being split
* @param bit the bit of hash to split on
*/
final void split(HashMap<K,V> map, Node<K,V>[] tab, int index, int bit) {
TreeNode<K,V> b = this;
// 重新链接到 lo 和 hi 列表，保留顺序
TreeNode<K,V> loHead = null, loTail = null;
TreeNode<K,V> hiHead = null, hiTail = null;
int lc = 0, hc = 0;
//循环遍历树 由于 TreeNode 节点之间存在双端链表的关系，可以利用链表关系进行 rehash
for (TreeNode<K,V> e = b, next; e != null; e = next) {
next = (TreeNode<K,V>)e.next;
e.next = null;
if ((e.hash & bit) == 0) {
if ((e.prev = loTail) == null) {
loHead = e;
} else {
loTail.next = e;
}
loTail = e;
++lc;
}
else {
if ((e.prev = hiTail) == null) {
hiHead = e;
} else {
hiTail.next = e;
}
hiTail = e;
++hc;
}
}
//rehash 操作之后注意对根据链表长度进行 untreeify 或 treeify 操作
if (loHead != null) {
if (lc <= UNTREEIFY_THRESHOLD) {
tab[index] = loHead.untreeify(map);
} else {
tab[index] = loHead;
//否则已经树化了
if (hiHead != null) {
loHead.treeify(tab);
}
}
}
if (hiHead != null) {
if (hc <= UNTREEIFY_THRESHOLD) {
tab[index + bit] = hiHead.untreeify(map);
} else {
tab[index + bit] = hiHead;
if (loHead != null) {
hiHead.treeify(tab);
}
}
}
}作者：咖啡兔
链接：https://juejin.cn/post/6952900921772900388
1601
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
