文章目录
前言
HashMap基于哈希表的实现的Map接口。 HashMap 允许 null 键和 null 值，在计算哈键的哈希值时，null 键哈希值为 0。HashMap 并不保证键值对的顺序，这意味着在进行某些操作后，键值对的顺序可能会发生变化。另外, 如果多个线程同时访问哈希映射，并且至少有一个线程在结构上修改了映射，那么它必须在外部进行同步。 （结构修改是添加或删除一个或多个映射的任何操作;仅改变与实例已经包含的密钥相关联的值不是结构修改。）这通常通过对自然地封装映射的一些对象进行同步来实现。 如果没有这样的对象存在，应该使用Collections.synchronizedMap方法“包装”。 这最好在创建时完成，以防止意外的不同步访问：
Map m = Collections.synchronizedMap(new HashMap(…));
一、先谈谈hashCode和hash算法
1. String 类型的 hashcode 方法
/**
* 返回此字符串的哈希码
* 计算公式为 s[0]*31^(n-1) + s[1]*31^(n-2) + ... + s[n-1]
* 空字符串的散列值为0
* @return a hash code value for this object.
*/
public int hashCode() {
int h = hash;
if (h == 0 && value.length > 0) {
char val[] = value;
for (int i = 0; i < value.length; i++) {
h = 31 * h + val[i];
}
hash = h;
}
return h;
}
就是String 的 char 数组的数字每次乘以 31 再叠加最后返回，因此，每个不同的字符串，返回的 hashCode 肯定不一样
2. 为什么大部分 hashcode 方法使用 31
在名著 《Effective Java 第二版》第 42 页就有对 hashCode 为什么采用 31 做了说明：
之所以使用 31， 是因为他是一个奇素数。如果乘数是偶数，并且乘法溢出的话，信息就会丢失，因为与2相乘等价于移位运算（低位补0）。使用素数的好处并不很明显，但是习惯上使用素数来计算散列结果。 31 有个很好的性能，即用移位和减法来代替乘法，可以得到更好的性能： 31 * i == (i << 5） - i， 现代的 VM 可以自动完成这种优化。这个公式可以很简单的推导出来。
3. 为什么没要使用hash & (n - 1) 而不直接使用 hashcode & (n - 1) 定位数组下标
1.先看看hash算法
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
-
先聊聊 按位与运算符（&）
-
如果相对应位都是1，则结果为1，否则为0
运算规则：0&0=0; 0&1=0; 1&0=0; 1&1=1;
即：两位同时为“1”，结果才为“1”，否则为0
另，负数按补码形式参加按位与运算。
以按位与运算符规则 (n -1)=15 二进制: 0000 0000 0000 0000 0000 0000 0000 1111
也就是说只要哈希码的后4位为0，不论不论高位怎么变化，最终的结果均为0
| (n -1)=15(length-1) | 0000 0000 0000 0000 0000 0000 0000 1111 |
|---|---|
| 65536 | 0000 0000 0000 0001 0000 0000 0000 0000 |
| &(与) | 0000 0000 0000 0000 0000 0000 0000 0000 |
而加上高16位异或低16位的“扰动函数”后(hash & (n - 1))，结果如下
| (n -1)=15(length-1) | 0000 0000 0000 0000 0000 0000 0000 1111 |
|---|---|
| 65536 | 0000 0000 0000 0001 0000 0000 0000 0000 |
| 65536 >>>16 | 0000 0000 0000 0000 0000 0000 0000 0001 |
| 65536 ^ 65536 >>>16异或运算符（^）（hash） | 1000 0000 0000 0000 0000 0000 0000 0001 |
| (n - 1) & hash | 0000 0000 0000 0000 0000 0000 0000 0001 |
扰动函数优化前：65536 % 16 = 65536 & (16 - 1) = 0
扰动函数优化后：65537% 16 = 65537 & (16 - 1) = 1 很显然，减少了碰撞的几率。
3. HashMap 的容量为什么建议是 2的幂次方？
公式:hash & (n - 1)
（&）与运算相对应位都是1，则结果为1，否则为0
当 n 为 2 的幂次方的时候，减一之后就会得到 1111… 的数字,能很好的参与运算
1.如果不使用 2 的幂次方作为数组的长度会怎么样？
-
假设数组长度15(n=15)
-
1110& 1010结果：1010= 10
1110& 1011结果：1010= 10
1110& 1110 结果： 1110= 14
1110& 1111 结果： 1110= 14
会导致这些不同的key值全部进入到相同的插槽中，形成链表，性能急剧下降。
1111& 1010结果：1010= 10
1111& 1011结果：1011= 11
1111& 1110 结果： 1110= 14
1111& 1111 结果： 1111= 15
当 n 为 2 的幂次方的时候，减一之后就会得到二进制 1111… 的数字 16-1(1111) 32-1(11111) 64-1(111111)
也就是说n为2的幂次方减一的到的二进制低位对位为0,不论不论高位怎么变化，最终的结果均为0
可以看到，当 n 为 2 的幂次方的时候，减一之后就会得到 1111… 的数字，
这个数字正好可以掩码。并且得到的结果取决于 hash 值。因为 hash 值是1，那么最终的结果也是1 ，hash 值是0，最终的结果也是0。
所以说，我们一定要保证 & 中的二进制位全为 1，才能最大限度的利用 hash 值，
并更好的散列，只有全是1 ，才能有更多的散列结果
二、源码分析
1.成员变量
/**
* 默认的初始容量,必须是2的幂 << 左移运算符 1左移4位 16
*/
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
/**
* 最大容量，如果两个带参数的构造函数中的任何一个隐式指定了更高的值，则使用该值.
* MUST be a power of two <= 1<<30.
*/
static final int MAXIMUM_CAPACITY = 1 << 30;
/**
* 默认的负载因子.
*/
static final float DEFAULT_LOAD_FACTOR = 0.75f;
/**
* 当桶(bucket)上的结点数大于这个值时会转成红黑树
*/
static final int TREEIFY_THRESHOLD = 8;
/**
* 当桶(bucket)上的结点数小于这个值时树转链表
*/
static final int UNTREEIFY_THRESHOLD = 6;
/**
* 桶中结构转化为红黑树对应的table的最小大小
*/
static final int MIN_TREEIFY_CAPACITY = 64;
/**
* 存储元素的数组，总是2的幂次倍
*/
transient Node<K, V>[] table;
/**
* 存放具体元素的集
*/
transient Set<Entry<K, V>> entrySet;
/**
* 此映射中包含的键-值映射的数量,存放元素的个数，注意这个不等于数组的长度。
*/
transient int size;
/**
* 每次扩容和更改map结构的计数器
*/
transient int modCount;
/**
* 临界值 当实际大小(容量*填充因子)超过临界值时，会进行扩容
* The next size value at which to resize (capacity * load factor).
*/
int threshold;
/**
* 哈希表的加载因子
*/
final float loadFactor;
2.构造方法
/**
* 无惨构造方法,将默认的加载因子0.75赋值给loadFactor
*/
public HashMap() {
// 将默认的加载因子0.75赋值给loadFactor，并没有创建数组
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
/**
* 指定容量大小的构造函数
*/
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
/**
* 指定的初始容量和负载因子
*/
public HashMap(int initialCapacity, float loadFactor) {
//边界值检查
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
//判断初始化容量initialCapacity是否大于集合的最大容量MAXIMUM_CAPACITY-》2的30次幂
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
//将指定的加载因子赋值给HashMap成员变量的负载因子loadFactor
this.loadFactor = loadFactor;
//table的初始化被推迟到了put方法中，在put方法中会对threshold重新计算
this.threshold = tableSizeFor(initialCapacity);
}
tableSizeFor()找到大于或等于 cap 的最小2的幂
/**
* 把输入值cap 变成最小的2的n次幂
*/
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;
}
tableSizeFor 方法的图解：
最后 n+1=16=2^4 得到的这个capacity赋值给了threshold
说明：
由此可以看到，当在实例化HashMap实例时，如果给定了initialCapacity(假设是10)，由于HashMap的capacity必须都是2的幂，因此tableSizeFor()
这个方法用于找到大于等于initialCapacity(假设是10)的最小的2的幂（initialCapacity如果就是2的幂，则返回的还是这个数）。
下面分析这个算法：
- 首先，为什么要对cap做减1操作。int n = cap - 1;
这是为了防止，cap已经是2的幂。如果cap已经是2的幂， 又没有执行这个减1操作，则执行完后面的几条无符号右移操作之后，返回的capacity将是这个cap的2倍。
如果不懂，要看完后面的几个无符号右移之后再回来看看。 - 如果n这时为0了（经过了cap-1之后），则经过后面的几次无符号右移依然是0，最后返回的capacity是 1（最后有个(n < 0) ? 1的操作）。
这里只讨论n不等于0的情况。 - |（按位或运算）运算规则：相同的二进制数位上，都是0的时候，结果为0，否则为1。
3.put过程
1.put逻辑
/**
* Associates the specified value with the specified key in this map.
* If the map previously contained a mapping for the key, the old
* value is replaced.
*
* @param key key with which the specified value is to be associated
* @param value value to be associated with the specified key
* @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
* @param key the key
* @param value the value to put
* @param onlyIfAbsent if true, don't change existing value
* @param evict if false, the table is in creation mode.
* @return previous value, or null if none
*/
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)
n = (tab = resize()).length;
//定位数组下标,如果不包含键值对节点引用，则将新键值对节点的引用存入桶中
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K, V> e;
K k;
// 如果键的值以及节点 hash 等于链表中的第一个键值对节点时，则将 e 指向该键值对
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
else if (p instanceof TreeNode) //key不同；判断p是否为红黑树结点
e = ((TreeNode<K, V>) p).putTreeVal(this, tab, hash, key, value);
else { // else 如果key不相同，只是hash冲突，并且不是树，则是链表
// 循环，直到链表中的某个节点为null，或者某个节点hash值和给定的hash值一致且key也相同，则停止循环。
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
// 如果链表长度达到了8，且数组长度小于64，那么就重新散列，如果大于64，则创建红黑树
treeifyBin(tab, hash);
break;
}
//next的hash值和hash相同(key也相同)
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
//结束循环
break;
// 如果给定的hash值不同或者key不同。
// 将next 值赋给 p，为下次循环做铺垫
p = e;
}
}
//如果e不等于null(表明该元素存在且他们的key相同)
if (e != null) { // existing mapping for key
//取出旧值
V oldValue = e.value;
//onlyIfAbsent如果为true同时 oldValue不等于null 则不覆盖现有值
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
//返回旧值
return oldValue;
}
}
//如果e== null，需要增加 modeCount 变量，为迭代器服务。
++modCount;
// 存放元素的个数大于临界值(容量*填充因子) 进行扩容
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
putVal 方法主要做了这么几件事情：
- 当桶数组 table 为空时，resize()初始化 table
- 查找要插入的键值对是否已经存在，onlyIfAbsent如果为false且oldValue等于null 则覆盖旧值
- 如果不存在，则将键值对链入链表中,如果链表长度达到了8，且数组长度小于64，那么就重新散列，如果大于64，则创建红黑树
- 判断键值对数量是否大于阈值，大于的话则进行扩容操作
2.resize
1.JDK1.8
final Node<K, V>[] resize() {
Node<K, V>[] oldTab = table;
//旧的容量
int oldCap = (oldTab == null) ? 0 : oldTab.length;
// 临界值
int oldThr = threshold;
int newCap, newThr = 0;
//如果老的容量大于0
if (oldCap > 0) {
//如果老的容量大于最大值
if (oldCap >= MAXIMUM_CAPACITY) {
//阈值设置未最大值
threshold = Integer.MAX_VALUE;
//反追老值
return oldTab;
// oldCap << 1 左移1位 相当于*2
//老的容量*2 小于最大容量并且老的容量大于等于默认容量
} else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
// 新的阀值也再老的阀值基础上*2
newThr = oldThr << 1; // double threshold
} else if (oldThr > 0) // initial capacity was placed in threshold
//初始容量设为阈值
newCap = oldThr;
else { // zero initial threshold signifies using defaults
// 0初始阈值表示使用默认的容量16和默认的阀值12
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int) (DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
// 如果新的阀值是0，重新计算阀值
if (newThr == 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) {//原来有值则复制到新Node数组里
// 把每个bucket都移动到新的buckets中
//遍历旧的哈希表的每个桶，重新计算桶里元素的新位置
for (int j = 0; j < oldCap; ++j) {
Node<K, V> e;
if ((e = oldTab[j]) != null) {
//原来的数据赋值为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
// 采用链表处理冲突
Node<K, V> loHead = null, loTail = null;
Node<K, V> hiHead = null, hiTail = null;
Node<K, V> next;
do {
next = e.next;
//判断如果等于true e这个节点在resize之后不需要移动位置
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
//原索引+oldCap (e.hash & oldCap) !=0 最高位对位为1
} else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
//e.next不等于null 将e.next值赋给e，为下次循环做铺垫
} while ((e = next) != null);
// 原索引放到索引为j的bucket里
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
// 原索引+oldCap放到索引为j+oldCap的bucket里
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
resize方法主要做了这么几件事情：
- 计算新桶数组的容量 newCap 和新阈值 newThr
- 根据计算出的 newCap 创建新的桶数组，桶数组 table 也是在这里进行初始化的
- 将键值对节点重新映射到新的桶数组里。如果节点是 TreeNode 类型，则需要拆分红黑树。如果是普通节点，则节点按原顺序进行分组
将键值对节点重新映射到新的tab解析:
HashMap在进行扩容时，使用的rehash方式非常巧妙，因为每次扩容都是翻倍，与原来的数组长度n计算的 (n-1)&hash的结果相比，只是多了一个bit位，所以节点要么就在原来的位置，要么就被分配到"原位置+旧容量"这个位置。那么多的这一位怎么判断是0还是1呢？：e.hash & oldCap原容量，然后判断等不等于0即可。等0即新位是0，不等0即新位是1。
例如我们从16扩展为32时，具体的变化如下所示：
&（按位与运算）：运算规则：相同的二进制数位上，都是1的时候，结果为1，否则为零。
因此元素在重新计算hash之后，因为n变为2倍，那么n-1的标记范围在高位多1bit(红色)，因此新的index就会发生这样的变化：
说明：5是假设计算出来的原来的索引。这样就验证了上述所描述的：扩容之后所以节点要么就在原来的位置，要么就被分配到"原位置+旧容量"这个位置。
因此，我们在扩充HashMap的时候，不需要重新计算hash，只需要看看原来的hash值新增的那个bit是1还是0就可以了，是0的话索引没变，是1的话索引变成“原索引+oldCap(原位置+旧容量)”。为1还是为0可以通过这个式子判断：(e.hash & oldCap) == 0，代表为0。
正是因为这样巧妙的rehash方式，既省去了重新计算hash值的时间，而且同时，由于新增的1bit是0还是1可以认为是随机的，在resize的过程中保证了rehash之后每个桶上的节点数一定小于等于原来桶上的节点数，保证了rehash之后不会出现更严重的hash冲突，均匀的把之前的冲突的节点分散到新的桶中了。
1.JDK1.7resize线程安全问题
//按新的容量扩容Hash表
void resize(int newCapacity) {
Entry[] oldTable = table;//老的数据
int oldCapacity = oldTable.length;//获取老的容量值
if (oldCapacity == MAXIMUM_CAPACITY) {//老的容量值已经到了最大容量值
threshold = Integer.MAX_VALUE;//修改扩容阀值
return;
}
//新的结构
Entry[] newTable = new Entry[newCapacity];
transfer(newTable, initHashSeedAsNeeded(newCapacity));//将老的表中的数据拷贝到新的结构中
table = newTable;//修改HashMap的底层数组
threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);//修改阀值
}
//将老的表中的数据拷贝到新的结构中
void transfer(Entry[] newTable, boolean rehash) {
int newCapacity = newTable.length;//容量
for (Entry<K,V> e : table) { //遍历所有桶
while(null != e) { //遍历桶中所有元素（是一个链表）
Entry<K,V> next = e.next;
if (rehash) {//如果是重新Hash，则需要重新计算hash值
e.hash = null == e.key ? 0 : hash(e.key);
}
int i = indexFor(e.hash, newCapacity);//定位Hash桶
e.next = newTable[i];//元素连接到桶中,这里相当于单链表的插入，总是插入在最前面
newTable[i] = e;//newTable[i]的值总是最新插入的值
e = next;//继续下一个元素
}
}
}
假设这里有两个线程同时执行了put()操作，并进入了transfer()环节：
while(null != e) {
//next是key:4 , e是key:0
Entry<K,V> next = e.next; //线程1执行到这里被挂起
if (rehash) {
e.hash = null == e.key ? 0 : hash(e.key);
}
int i = indexFor(e.hash, newCapacity);
e.next = newTable[i];
newTable[i] = e;
e = next;
}
线程2调度完成所有节点的移动，移动后结果为：
线程1继续执行，线程一会把线程二的新表当成原始的hash表，将原来e指向的key(0)节点当成是线程二中的key(0),放在自己所建table[0]的头节点。注意线程1的next仍然指向key(4)，
虽然此时key(0)的next已经是null。
线程1执行:
-
执行e.next = newTable[i]，于是 key(0)的 next 指向了线程1的新 Hash 表，因为新 Hash 表为空，所以e.next = null
-
.执行newTable[i] = e，所以线程1的新 Hash 表第一个元素指向了线程2新 Hash 表的 key(0)。
-
执行e = next，将 e 指向 next，所以新的 e 是 key(4)
-
while第二次循环,现在的 e 节点是 key(4)，首先执行Entry<K,V> next = e.next,那么 next 就是 key(0)了
(线程2里面key(0)就是key(4)的下一个节点) -
执行e.next = newTable[i]，于是key(0) 的 next 就成了 key(4)
-
.执行newTable[i] = e，那么线程1的新 Hash 表第一个元素变成了 key(4)
-
执行e = next，将 e 指向 next，所以新的 e 是 key(0)
-
现在的 e 节点是 key(0)，首先执行Entry<K,V> next = e.next,那么 next 就是 null
-
执行e.next = newTable[i]，于是key(0) 的 next 就成了 key(4)
-
执行newTable[i] = e，那么线程1的新 Hash 表第一个元素变成了 key(0)
-
执行e = next，将 e 指向 next，所以新的 e 是 key(4)
到这里已经出现环形指向
HashMap(1.7)在put的时候，插入的元素超过了容量（由负载因子决定）的范围就会触发扩容操作，就是rehash，这个会重新将原数组的内容重新hash到新的扩容数组中，在多线程的环境下，存在同时其他的元素也在进行put操作，如果hash值相同，可能出现同时在同一数组下用链表表示，造成闭环，导致在get时会出现死循环，所以HashMap是线程不安全的。
3.treeifyBin
/**
* Replaces all linked nodes in bin at index for given hash unless
* table is too small, in which case resizes instead.
替换指定哈希表的索引处桶中的所有链接节点，除非表太小，否则将修改大小。
Node<K,V>[] tab = tab 数组名
int hash = hash表示哈希值
*/
final void treeifyBin(Node<K,V>[] tab, int hash) {
int n, index; Node<K,V> e;
//长度大于64才会树化，如果小于 64只会进行扩容
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
resize();//只是扩容tab[]
else if ((e = tab[index = (n - 1) & hash]) != null) {
/*
1）执行到这里说明哈希表中的数组长度大于阈值64，开始进行树形化
2）e = tab[index = (n - 1) & hash]表示将数组中的元素取出赋值给e
*/
//hd：红黑树的头结点head tl :红黑树的尾结点tail
TreeNode<K,V> hd = null, tl = null;
do {
//把链表的当前结点转成一个树结点。
TreeNode<K,V> p = replacementTreeNode(e, null);//如何转成红黑树：首先根据原来Node结点的顺序转成一个双向链表，即增加一个pre指针，然后再根据这个双向链表从上到下依次插入到一颗红黑树中，转成一棵树
if (tl == null)
//将新创键的p节点赋值给红黑树的头结点
hd = p;
else {
p.prev = tl;//将上一个节点p赋值给现在的p的前一个节点
tl.next = p;//将现在节点p作为树的尾结点的下一个节点
}
tl = p;
} while ((e = e.next) != null);//更新结点 且 判断是否继续查找
/*
让桶中的第一个元素即数组中的元素指向新建的红黑树的节点，以后这个桶里的元素就是红黑树
而不是链表数据结构了
*/
if ((tab[index] = hd) != null)
hd.treeify(tab);//在这里把双线链表转成红黑树
}
}
treeify()：双向链表转成红黑树
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.left = x.right = null;
if (root == null) {//第一个结点直接作为红黑树根节点
x.parent = null;
x.red = false;
root = x;
}
else {
K k = x.key;
int h = x.hash;
Class<?> kc = null;//key的class类型
for (TreeNode<K,V> p = root;;) {//遍历现有红黑树
int dir, ph;
K pk = p.key;//p是红黑树里的当前结点，x是我们要插入的结点
//要插入得先比较，但先比较的是哈希值，
if ((ph = p.hash) > h)//如果红黑树里当前结点p的哈希值大于要插入的结点x哈希值
dir = -1;//direction，往左子树查
else if (ph < h)//p的哈希值小于x的哈希值
dir = 1;//往右子树查
//等于
else if ((kc == null && (kc = comparableClassFor(k)) == null) ||
//如果kc为空就先赋值kc//如果该key实现了Comparable<C>可进行比较，就返回Class对象。没实现就返回null //这里应该这是插入根节点的时候或的前半部分才为true，从第二个开始或语句的前半句就不满足了，直接执行或的后半句
(dir = compareComparables(kc, k, pk)) == 0)//前面只是比较哈希值，哈希值相对未必就key相等，所以进一步比较p的key和x的key，并且把结果给dir
//如果上面的dir==0满足，就进行插入，否则继续进行再查找
dir = tieBreakOrder(k, pk);
TreeNode<K,V> xp = p;
if ((p = (dir <= 0) ? p.left : p.right) == null) {//看向左还是向右查找，更新红黑树的当前结点 //如果进入if，代表没有x对应的这个key值，要进行插入了
x.parent = xp;
if (dir <= 0)
xp.left = x;
else
xp.right = x;//先连接上，再调整
root = balanceInsertion(root, x);//当前结点插入到红黑树中
break;
}
}
}
}
moveRootToFront(tab, root);//把根节点赋值给HashMap的table[i]//树结点同时也是以链表形式存在的
//红黑树生成的过程中只是改变了left和right，而原来的next和prev还在，所以还是可以拿双线链表查出来原来后红黑树前的顺序的。我们的结点同时是链表里的一个结点，同时也是红黑树里的一个节点。
//但这里还是做了一些变化的，他让红黑树里根节点那个结点移动到了双向链表的头部，即单独单出来放到头部，其他结点再双向链表中的相对顺序不变，包括因拿出来根节点断掉的那个地方，也自动粘合拼接了。
}
4.get过程
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
// 1. 定位键值对所在桶的位置
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
return first;
if ((e = first.next) != null) {
// 2. 如果 first 是 TreeNode 类型，则调用黑红树查找方法
if (first instanceof TreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
// 2. 对链表进行查找
do {
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}
总结
HashMap 常见操作相关代码进行了详细分析，插入操作一节的内容说的最多，主要是因为插入操作涉及的点特别多。包含但不限于“table 初始化、扩容、树化”等，总体来说，插入操作分析起来难度还是很大的。
才疏学浅，难免会有纰漏，如果你发现了错误的地方，可以在留言区提出来，我对其加以修改。
感谢您的阅读
105
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
