在我们的面试中HashMap基本上是一个逃不开的知识点，本文就带你一起学习HashMap的部分源码。如果有不正确的地方，欢迎指正。祝你学习愉快。
由于网上大部分的解析都是基于JDK1.8的，然而我的JDK是11。所以我就来写一篇HashMap在JDK11中的源码剖析。如果后面有机会，我会再写关于1.8的(不过貌似源码差不多)。
文章目录
如果想看理论性的东西，下面的传送门欢迎你！！！
1、类的基本关系
![[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-RtcHip8l-1585645322150)(HashMap.assets/image-20200331094424582.png)]](https://img-blog.csdnimg.cn/2020033117110824.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQ0Mzc3NzA5,size_16,color_FFFFFF,t_70)
说明：
- Cloneable接口：该接口为系统的一个克隆接口
- Serializable 接口：实现该接口的类，可以被序列化和反序列化
我们发现AbstractMap 和HashMap类都实现了Map类，这貌似有一点多余吧，这里穿插一点历史
据 java 集合框架的创始人Josh Bloch描述，这样的写法是一个失误。在java集合框架中，类似这样的写法很多，最开始写java集合框架的时候，他认为这样写，在某些地方可能是有价值的，直到他意识到错了。显然的，JDK的维护者，后来不认为这个小小的失误值得去修改，所以就这样存在下来了。
2、成员变量
1、序列化版本号
private static final long serialVersionUID = 362498820763181265L;
2、default_initial_capacity（默认的初始容量），这里指集和的默认初始容量为16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
3、maximum_capacity（最大容量），这里指集和的最大容量是2的30次
static final int MAXIMUM_CAPACITY = 1 << 30;
4、default_load_factor（默认的加载因子），与map集和的容量有关
static final float DEFAULT_LOAD_FACTOR = 0.75f;
5、treeify_threshold（树的阈值），链表转换为红黑树的边界值
static final int TREEIFY_THRESHOLD = 8;
6、untretreeify_threshold（不是树的阈值），红黑树转换成链表的边界值
static final int UNTREEIFY_THRESHOLD = 6;
7、min_treeify_capacity（最小容量），hash表的结构由链表转换成红黑树的最小容量
static final int MIN_TREEIFY_CAPACITY = 64;
8、用来初始化（1.7时Node为Entry<K,V>）
transient Node<K,V>[] table;
//在后文出现的这个类，负责存储键值对的数据
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
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;
}
public final K getKey() { return key; }
public final V getValue() { return value; }
public final String toString() { return key + "=" + value; }
//返回对应的hashCode值
public final int hashCode() {
return Objects.hashCode(key) ^ Objects.hashCode(value);
}
//设置key对应的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;
//instanceof是Java中的一个双目运算符，用来测试一个对象是否为一个类的实例
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;
}
}
9、用来存放缓存
transient Set<Map.Entry<K,V>> entrySet;
10、size表示存储map集和的元素个数，这个个数和数组的长度有区别
transient int size;
11、记录集和修改的次数
transient int modCount;
12、集和容量的临界值，用来扩大集和
int threshold;
13、加载因子，前面是有一个默认的，我们也可以进行修改
final float loadFactor;
3、构造方法
1、自定义集和初始容量和自定义加载因子的构造方法
//实例化的时候，HashMap(自定义集和初始容量,自定义加载因子)。当然，如果我们不传入，也会有对应的默认值(1 << 4,0.75)
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，或者传入的加载因子所表示的值是NaN（具体查看补充方法一）时抛出异常
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
//将自定义的加载因子进行传值
this.loadFactor = loadFactor;
//返回一个2的幂次方数，赋值给我们的集和容量（具体查看补充方法二），即如果我们如果传入的数据不是2的次幂方数，这里会进行一个转换，系统帮我们转换成一个2的幂次方数（涉及数学运算）
this.threshold = tableSizeFor(initialCapacity);
}
补充方法一：判断是否是NaN类型
//这个可以类比JS中得NaN，传入一个正常的数字，肯定会返回false，但如果传入的是一个NaN类型就为true（0.0f/0.0f就是一个NaN类型）
public static boolean isNaN(float v) {
return (v != v);
}
补充方法二：返回比自定义初始化容量大的最小的2的n次幂
//该方法返回比自定义初始化容量大的最小的2的n次幂
static final int tableSizeFor(int cap) {
//将-1进行无符号的右移与 运算结果返回相同的位数（具体查看补充方法三）
int n = -1 >>> Integer.numberOfLeadingZeros(cap - 1);
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}
补充方法三：获取传入数字的最高为1的位置
//该方法就是用来获取传入数字的最高为1的位置
//i为我们自定义的集和的初始容量-1
public static int numberOfLeadingZeros(int i) {
if (i <= 0)
//如果i为-1，返回回值也位0，且我们的自定义数组长度为0；如果i为0，则返回32（即-1无符号右移32位）
return i == 0 ? 32 : 0;
int n = 31;
//获取最高为（一顿骚操作的数学运算，可自行验证）
if (i >= 1 << 16) { n -= 16; i >>>= 16; }
if (i >= 1 << 8) { n -= 8; i >>>= 8; }
if (i >= 1 << 4) { n -= 4; i >>>= 4; }
if (i >= 1 << 2) { n -= 2; i >>>= 2; }
return n - (i >>> 1);
}
2、自定义集和初始化容量的构造方法
public HashMap(int initialCapacity) {
//自定义了初始化容量，加载因子使用系统默认的
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
3、无参构造，默认初始容量（16）和默认负载因子（0.75）
public HashMap() {
//使用系统默认的参数
this.loadFactor = DEFAULT_LOAD_FACTOR;
}
4、包含Map的构造方法
//传入一个map集，与指定的KV键值对拥有继承关系
public HashMap(Map<? extends K, ? extends V> m) {
//赋值默认的加载因子
this.loadFactor = DEFAULT_LOAD_FACTOR;
//将map集和的数据传入到HashMap中（具体查看补充方法四）
putMapEntries(m, false);
}
补充方法四：将两个集和进行数据交换（该方法不再下探）
final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) {
//获取传入的集和的长度
int s = m.size();
if (s > 0) {
//判断table是否被初始化（成员变量第8个）
if (table == null) {
//未初始化，s为m的实际元素个数（在后面我们会讲解数组的实际存储长度=加载因子*数组的长度）
//加1.0F与(int)ft相当于是对小数做一个向上取整以尽可能的保证更大容量，更大的容量能够减少resize的调用次数。所以 + 1.0F是为了获取更大的容量
float ft = ((float)s / loadFactor) + 1.0F;
//判断传入的集和最大容量的关系，
int t = ((ft < (float)MAXIMUM_CAPACITY) ?
(int)ft : MAXIMUM_CAPACITY);
// 计算得到的t大于集和容量的临界值，则初始化这个集和容量
if (t > threshold)
//具体查看补充的方法体二，返回比自定义初始化容量大的最小的2的n次幂
threshold = tableSizeFor(t);
}
// 已初始化，并且m集和个数大于结合容量，则进行扩容处理
else if (s > threshold)
//由于该方法的代码量较多，我们后面讲解，此处你只需要记住，这个方法是用来扩大数组的
resize();
// 将m集和中的所有元素添加至HashMap集和中
for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
K key = e.getKey();
V value = e.getValue();
//这里就是一个依次赋值的方法，会后讲put时会讲解
putVal(hash(key), key, value, false, evict);
}
}
}
4、成员方法
4.1、put 添加key-value(重点)
//当我们调用put方法时，其实是调用了putVal方法
public V put(K key, V value) {
//传入参数位：key的hash值，key，value，以及两个布尔值。具体计算hash值的反法，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; 表示存储Map集合中元素的数组。
//Node<K,V> p p表示原来的节点
Node<K,V>[] tab; Node<K,V> p; int n, i;
//(tab = table) == null 表示用来初始化的空的table赋值给tab,然后判断tab是否等于null，第一次肯定是null
//(n = tab.length) == 0 表示将数组tab的长度0赋值给n,然后判断n是否等于0，为真，则执行代码 n = (tab = resize()).length; 进行数组初始化。并将初始化好的数组长度赋值给n.
if ((tab = table) == null || (n = tab.length) == 0)
//n = (tab = resize()).length，得到扩容以后数组的长度
n = (tab = resize()).length;
//1、i = (n - 1) & hash 表示利用数组的长度和hash值，计算数组的索引赋值给i
//2、p = tab[i = (n - 1) & hash]表示获取计算出的索引位置的数据赋值给原来的节点p
//3、判断节点是否为null，如果为空则执行对应代码
if ((p = tab[i = (n - 1) & hash]) == null)
//创建一个新的节点，将数据放入数组tab的指定索引位置上
tab[i] = newNode(hash, key, value, null);
//如果不为空
else {
Node<K,V> e; K k;
//1、p.hash == hash 判断原来数据的hash值和添加数据的hash值是否相等
//2、(k = p.key) == key 获取原来数据的key赋值给k，然后再与添加的数据key进行地址值的比较
//3、(key != null && key.equals(k)) 添加的数据key是都为空且添加的key和原来数据的key是否相同
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
//如果条件判断为真，则将p节点赋值给新的节点e
//总结一句话就是：如果新传入的key的hash值与之前的存在的节点相同，那么就会调用equals方法进行判断，如果key的内容也相同，则可以认为是相同的key，则进行key与value的替换
e = p;
//在节点不为空且key的hash值不同的前提下，判断原来的节点是否为红黑树类型
else if (p instanceof TreeNode)
//如果是，则进行对应红黑树的操作（本文暂不讲解该块知识点）
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
//节点不为空，key也不相同，又不是红黑树节点，则说明该节点是链表节点
//循环遍历整个链表
for (int binCount = 0; ; ++binCount) {
//如果在遍历的过程中，遇到了某个节点的下一个节点为null，则说明此时遍历到了链表的底端
if ((e = p.next) == null) {
//将新的节点数据进行插入
p.next = newNode(hash, key, value, null);
//如果插入以后长度大于等于了树的阈值8-1（成员变量5），就将链表数据结构，转换成红黑树的数据结构
if (binCount >= TREEIFY_THRESHOLD - 1)
//后面专门讲解这个方法
treeifyBin(tab, hash);
break;
}
//如果在遍历的过程中，遇到了某个节点的key的hash与内容都相同时，则跳出循环
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
//将赋值成功的新的节点e，重新返回赋值给p（与前文代码照应）
p = e;
}
}
//将之前数据key的hash值与key的内容相同的进行value的修改
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
//访问后进行回调（让数据的顺序保持与之前的相同，JDK1.7就因为修改后数据的顺序不同造成死锁）具体方法详情，请查看补充方法六
afterNodeAccess(e);
return oldValue;
}
}
//修改次数加1
++modCount;
//判断插入数据后，存储的元素是否大于数组长度
if (++size > threshold)
resize();
//插入后回调，具体方法详情，请查看补充方法六
afterNodeInsertion(evict);
return null;
}
补充方法五：
static final int hash(Object key) {
int h;
//进行相应的运算（这里又是一顿数学运算）
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
补充方法六：
// Callbacks to allow LinkedHashMap post-actions(仅从writeObject调用，以确保排序兼容。)
//这涉及到LinkedHashMap，emmm我还没学，不知道！！！
void afterNodeAccess(Node<K,V> p) { }
void afterNodeInsertion(boolean evict) { }
void afterNodeRemoval(Node<K,V> p) { }
补充一个put方法的程序流程图：
4.2、treeifyBin 链表转换成红黑树(重点)
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
//binCount从0开始，0表示第一个节点，6表示第七个节点，不会进入循环。7表示第八个节点，会进入循环，继而进行红黑树的转换（7表示本身已经有八个节点，再加上新添加的节点数据，就有9个了，就会进行红黑树的转换）
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
......
}
final void treeifyBin(Node<K,V>[] tab, int hash) {
int n, index; Node<K,V> e;
//如果当前数组为空或者数组的长度小于进行树形化的阈值(MIN_TREEIFY_CAPACITY = 64),
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
//进行扩容
resize();
//执行到这里，说明hash表中的数组长度已经大于64了
//e = tab[index = (n - 1) & hash]表示将集和数组中的元素取出赋值给e,e是哈希表中指定位置里的链表节点，从第一个开始
else if ((e = tab[index = (n - 1) & hash]) != null) {
//hd：红黑树的头结点 tl :红黑树的尾结点
TreeNode<K,V> hd = null, tl = null;
//链表转换成红黑树
do {
//新创建一个树的节点，内容和当前链表节点e一致
TreeNode<K,V> p = replacementTreeNode(e, null);
if (tl == null)
//将新创键的p节点赋值给红黑树的头结点
hd = p;
else {
//p.prev = tl：将上一个节点p赋值给现在的p的前一个节点
p.prev = tl;
//tl.next = p;将现在节点p作为树的尾结点的下一个节点
tl.next = p;
}
tl = p;
//e = e.next 将当前节点的下一个节点赋值给e,如果下一个节点不等于null，循环整个链表，将数据转换成红黑树
} while ((e = e.next) != null);
//让数组中的元素指向新建的红黑树的节点，以后这个位置里的元素就是红黑树而不是链表了
if ((tab[index] = hd) != null)
hd.treeify(tab);
}
}
4.3、resize 扩容数组(重点)
每次扩容，都需要重新分配所有元素的位置
当HashMap中的其中一个链表的对象个数如果达到了8个，此时如果数组长度没有达到64，那么HashMap会先扩容解决，如果已经达到了64，那么这个链表会变成红黑树，节点类型由Node变成TreeNode类型。当然，如果映射关系被移除后，下次执行resize方法时判断树的节点个数低于6，也会再把树转换为链表
final Node<K,V>[] resize() {
//获得当前数组
Node<K,V>[] oldTab = table;
//判断数组是否为null，并返回数组长度
int oldCap = (oldTab == null) ? 0 : oldTab.length;
//集和容量=数组长度*负载因子（默认为16*0.75=12）
int oldThr = threshold;
int newCap, newThr = 0;
//如果原数组的长度大于0
if (oldCap > 0) {
//原数组的长度大于1<<30，则超过了最大值
if (oldCap >= MAXIMUM_CAPACITY) {
//将Integer的最大值赋值给这个数组的边界（最大值为21亿多）
threshold = Integer.MAX_VALUE;
return oldTab;
}
//(newCap = oldCap << 1) < MAXIMUM_CAPACITY 扩大到2倍之后容量是否小于最大容量？
//oldCap >= DEFAULT_INITIAL_CAPACITY 原数组长度是否大于等于数组初始化长度16
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
//如果是就将数组的容量扩大一倍
newThr = oldThr << 1; // double threshold
}
//如果原数组的容量是大于0，就直接将原来的数组容量赋值给新得数组长度
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
//除此之外，新得数组长度和数组容量使用默认值
else { // zero initial threshold signifies using defaults
//新的数组长度为16
newCap = DEFAULT_INITIAL_CAPACITY;
//新得数组容量为12
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
//计算新的resize最大上限
if (newThr == 0) {
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
//将新的数组容量赋值给默认得数组容量变量
threshold = newThr;
//创建一个新的hash表，且数组长度为新的数组长度
@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;
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
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;
}
// 原索引+oldCap放到对用位置里
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
扩容后各元素的位置：要么在原位置，要么在原位置+原数组长度的那个位置上（for循环代码）
4.4、remove 根据key删除元素
public V remove(Object key) {
Node<K,V> e;
return (e = removeNode(hash(key), key, null, false, true)) == null ?
null : e.value;
}
final Node<K,V> removeNode(int hash, Object key, Object value,
boolean matchValue, boolean movable) {
Node<K,V>[] tab; Node<K,V> p; int n, index;
//根据hash找到对应的位置，如果位置不为null
if ((tab = table) != null && (n = tab.length) > 0 &&
(p = tab[index = (n - 1) & hash]) != null) {
Node<K,V> node = null, e; K k; V v;
//如果对应位置的节点就是要找的key，则将node指向该节点
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
node = p;
//如果下一个节点不为空，则进行下一步判断
else if ((e = p.next) != null) {
//如果这个节点为红黑树
if (p instanceof TreeNode)
//说明是以红黑树来处理的冲突，则获取红黑树要删除的节点
node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
else {
//判断是否以链表方式处理hash冲突，是的话则通过遍历链表来寻找要删除的节点
do {
if (e.hash == hash &&
((k = e.key) == key ||
(key != null && key.equals(k)))) {
node = e;
break;
}
p = e;
} while ((e = e.next) != null);
}
}
//比较找到的key的value和要删除的是否匹配
if (node != null && (!matchValue || (v = node.value) == value ||
(value != null && value.equals(v)))) {
//如果是红黑树，就调用红黑树的方法来删除节点
if (node instanceof TreeNode)
((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
else if (node == p)
//如果是链表，就用链表删除
tab[index] = node.next;
else
p.next = node.next;
//记录修改次数
++modCount;
//变动的数量减1
--size;
//又是LinkedHashMap相关的操作
afterNodeRemoval(node);
return node;
}
}
return null;
}
4.5、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;
//如果哈希表不为空并且key对应的的索引位置上也不为空
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
//是否满足hash值与第一个位置的hash值相同，并且第一个位置上的key是否和传入的key相同或内容相同
if (first.hash == hash && // always check first node 总是检查第一个元素
((k = first.key) == key || (key != null && key.equals(k))))
//如果满足，则说明第一个元素就是要查找的元素，那就直接返回
return first;
if ((e = first.next) != null) {
//判断是否是红黑树，是的话调用红黑树中的getTreeNode方法获取对应的节点
if (first instanceof TreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
//如果不是红黑树结构，那就是链表结构，通过循环遍历链表结构中是否存在符合条件的key
do {
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}
补充红黑树查找的对应数据的方法（有兴趣可以查看）
final TreeNode<K,V> getTreeNode(int h, Object k) {
return ((parent != null) ? root() : this).find(h, k, null);
}
final TreeNode<K,V> find(int h, Object k, Class<?> kc) {
TreeNode<K,V> p = this;
//添加数据如果是添加到红黑树中，那么数据就是有序的。此时利用循环进行折半查找
//对比节点的哈希值和要查找的哈希值是否相等，再判断key是否相等，相等就直接返回。不相等就继续查找
do {
int ph, dir; K pk;
TreeNode<K,V> pl = p.left, pr = p.right, q;
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;
}
get方法实现的步骤：
-
通过hash值获取该key映射到的桶
-
桶上的key就是要查找的key,则直接找到并返回
-
桶上的key不是要找的key,则查看后续的节点：
- 如果后续节点是红黑树节点，通过调用红黑树的方法根据key获取value
- 如果后续节点是链表节点，则通过循环遍历链表根据key获取value
至此，hashmap的几个重要方法的执行流程已经讲解完毕，但是面试基本只会问原理，源码的流程只是为了让我们更好的理解原理
传送门：
HashMap原理讲解
