本文件出处https://shenyifengtk.github.io/2020/05/10/HashMap源码解析
转载请说明出处以后面试官问你HashMap原理，不能再答数组+链表的结构了，
JDK1.8添加了红黑树结构，知识要与时俱进啊。受限于文章篇幅，我会从HashMap 初始化，put、get方面解析底层原理。
内部设定
常量设定
/**
* HashMap 默认初始化长度
*/
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
/**
* HashMap 允许容器数组最大长度
*/
static final int MAXIMUM_CAPACITY = 1 << 30;
/**
* 负载因子，容器数量/容器最大长度 大于等于，数组进行扩容
*/
static final float DEFAULT_LOAD_FACTOR = 0.75f;
/**
* 链表的长度超过阈值，在添加元素的时候链表转化成红黑树
*/
static final int TREEIFY_THRESHOLD = 8;
/**
* 在扩容的时候，红黑树数量小于阈值转换成链表
*/
static final int UNTREEIFY_THRESHOLD = 6;
/**
* 最小table 容器数量支持链表树化
*/
static final int MIN_TREEIFY_CAPACITY = 64;内部元素结构
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; }
public final int hashCode() {
return Objects.hashCode(key) ^ Objects.hashCode(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;
}
}Node对象只拥有三个属性，key，value，next，结构非常简单，操作也简单。
内部属性变量
/**
* 内部数组，上面所说table 指的就是这个
*/
transient Node<K,V>[] table;
/**
* entrySet() 返回容器
*/
transient Set<Map.Entry<K,V>> entrySet;
/**
* 键值对的数量，也是HashMap size
*/
transient int size;
/**
* HashMap 结构修改次数
*/
transient int modCount;
/**
* 扩容table 阈值
*/
int threshold;
/**
* 扩容因子
*/
final float loadFactor;
解析代码
构造函数
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);
}
/**
* Constructs an empty <tt>HashMap</tt> with the specified initial
* capacity and the default load factor (0.75).
*
*/
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
/**
* Constructs an empty <tt>HashMap</tt> with the default initial capacity
* (16) and the default load factor (0.75).
*/
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}这段代码很简单，主要是判断两个输入参数是否合法，将容器长度重新计算扩容阈值。
看下tableSizeFor怎么计算阈值
/**
* Returns a power of two size for the given target capacity.
*/
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;
}这个方法其实通过输入数，返回一个最接近大于等于他的2次方数。
通过将cap 高位1不断右移，返回cap最近2次方的数。如果有同学看不懂这个算法，可以参考这位老哥写的https://blog.csdn.net/fan2012huan/article/details/51097331，解析得非常易懂。
上面的构造函数，并没有初始化Node 数组，我进入put方法看下怎么样初始化的！
添加元素
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
/**
* @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) {
//p 如果存在就是链头
Node<K,V>[] tab; Node<K,V> p; int n, i;
//数组未初始化
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//根据hash 值 计算数组下标位置，这个位置下没有元素
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null); //插入元素
else {//hash 值冲突
Node<K,V> e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k)))) //key 相等
e = p;
else if (p instanceof TreeNode) //红黑树
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
for (int binCount = 0; ; ++binCount) { //遍历链表，插入数据
if ((e = p.next) == null) { //下一个元素为空，说明已经遍历到最后一个元素 ，插入 终止循环
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // 到达转化成树链的阈值
treeifyBin(tab, hash); //将链表转换成树
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k)))) //出现key 相等
break;
p = e;
}
}
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e); //空方法 ，LinkedHashMap 实现
return oldValue;
}
}
++modCount;
if (++size > threshold) //超出阈值
resize();
afterNodeInsertion(evict);
return null;
}整体流程： 先判断数组为空，没有则使用resize()方法初始化数组，使用hash 值& 数组长度计算下标，下标值为空，直接插入。处理hash冲突情况，先判断链头key是否相等，判断数组Node是否树链，则使用putTreeVal方法插入树链中，否则遍历链表在结尾插入。最后判断数组元素是否超过阈值，使用reszie()扩容。这个流程基本和我们平常写业务代码差不多。
计算hash方法
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}假设没有这个hash算法，对象hashCode直接&数组长度(n-1),当n比较小的时候，hash虽然是32位整数，但是只要低位是有效的，hash冲突概率比较大，会导致链表比较长。使用hash方法将高16位影响到低16位，将低16位的二进制打散了，减少了hash冲突概率。resize扩容，初始化数组方法
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)
newThr = oldThr << 1; // double threshold
}
else if (oldThr > 0) // 使用构造函数cap初始化数组长度
newCap = oldThr;
else { // zero initial threshold signifies using defaults
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
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) {
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {
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 { //将链条分成两个链条，一个是原数组下标，另一个则下标 x 2移动下标
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
next = e.next;
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
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;
}整体流程还是比较简单的，先确定数组长度，threshold属性，创建新数组移动copy元素，删除原数组元素。这个方法基本就是初始化table数组，扩容数组，处理链条或树链的内部细节。if ((e.hash & oldCap) == 0) { 这个写法，看了好久才明白什么意思啊。我们都知道数组长度永远都是2的次方，二进制表现就是最高位是1 其他都是0， 比如默认长度16 ，二进制就是10000。 计算数组长度算法e.hash & (oldCap- 1)， 长度-1 二机制的数11111,先数组扩容长度 * 2，计算下标结果下标前面不变，最高位是0还是1，是0保存下标不变，是1表示下标需要x 2.。觉得讲得不清楚，可以看下图
下面了解拆分树链的split
/**
* @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;
// 按hash 计算结果区分两个树链，统计树链的长度
TreeNode<K,V> loHead = null, loTail = null;
TreeNode<K,V> hiHead = null, hiTail = null;
int lc = 0, hc = 0;
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;
}
}
if (loHead != null) {
if (lc <= UNTREEIFY_THRESHOLD)
tab[index] = loHead.untreeify(map); //拆分树链转化成链条结构
else {
tab[index] = loHead;
if (hiHead != null) // (else is already treeified)
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);
}
}
}首先要知道TreeNode间接继承Node，拥有单向链条的属性。理解上面流程就很简单了，先遍历树链，按照hash & 数组长度方式，分成移动下标和不移动两个类型树链。再判断链条数量是否大于UNTREEIFY_THRESHOLD(6) ,满足使用untreeify方法拆分成链条。如果树链头不为空，则说明红黑树结构依然存在，使用treeify方法将链表转换成树链。
要理解链表怎么转化成树链，必须深入treeify方法
final void treeify(Node<K,V>[] tab) {
TreeNode<K,V> root = null;
//从this 链头开始遍历
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) { //root 根元素
x.parent = null;
x.red = false;
root = x;
}
else {
K k = x.key;
int h = x.hash;
Class<?> kc = null;
for (TreeNode<K,V> p = root;;) {
int dir, ph;
K pk = p.key;
if ((ph = p.hash) > h)
dir = -1;
else if (ph < h)
dir = 1;
else if ((kc == null &&
(kc = comparableClassFor(k)) == null) ||
(dir = compareComparables(kc, k, pk)) == 0)
dir = tieBreakOrder(k, pk);
TreeNode<K,V> xp = p;
if ((p = (dir <= 0) ? p.left : p.right) == null) { //如果子节点黑红都是null，直接插入指向，否则向下递归
x.parent = xp;
if (dir <= 0)
xp.left = x;
else
xp.right = x;
root = balanceInsertion(root, x); //调整节点位置，着色，左旋或者右旋
break;
}
}
}
}
moveRootToFront(tab, root); //判断root是否根节点，如果不是插入根节点位置
}看到这里，大家是不是跟我一样，觉得代码写得还是比较简单的，没什么难度啊。下面代码就不是这样了，没有一点黑红树基础的同学，麻烦先补下课先，不然你很难理解代码什么意思。
红黑树的性质
- 节点是红色或黑色。
- 根节点是黑色。
- 所有叶子都是黑色（叶子是NIL节点）
- 每个红色节点的两个孩子节点必须是黑色. (从叶子到根的所有路径上不能有两个连续的红色节点)
- 从任意节点到其叶子节点的所有路径都包含相同数目的黑色节点。
在红黑树插入或删除情况，上面的特征可能会被打破。所以要使用balanceInsertion方法平衡树链结构。我们在分析代码的时候，一定要把上面5个性质带上有助于理解。
static <K,V> TreeNode<K,V> balanceInsertion(TreeNode<K,V> root,
TreeNode<K,V> x) {
x.red = true; //默认x 就是红色
for (TreeNode<K,V> xp, xpp, xppl, xppr;;) {
//x 的父节点xp为空，则说明x 就是根节点 , 根据1属性，节点变成黑色就可以了
if ((xp = x.parent) == null) {
x.red = false;
return x;
}
//父节点黑色，插入红色，以上条件都满足，终止循环
else if (!xp.red || (xpp = xp.parent) == null)
return root;
if (xp == (xppl = xpp.left)) {
//见图1-1 ，不满足性质4、性质5，改变着色，向上递归
if ((xppr = xpp.right) != null && xppr.red) {
xppr.red = false;
xp.red = false;
xpp.red = true;
x = xpp;
}
else {
//见图1-2 不满足 性质4，xp左移
if (x == xp.right) {
root = rotateLeft(root, x = xp);
xpp = (xp = x.parent) == null ? null : xp.parent;
}
// 图1-3情况 不满足性质4，xpp 右移 调整着色
if (xp != null) {
xp.red = false;
if (xpp != null) {
xpp.red = true;
root = rotateRight(root, xpp);
}
}
}
}
else { //位置相反，流程一样，位置互换即可
if (xppl != null && xppl.red) {
xppl.red = false;
xp.red = false;
xpp.red = true;
x = xpp;
}
else {
if (x == xp.left) {
root = rotateRight(root, x = xp);
xpp = (xp = x.parent) == null ? null : xp.parent;
}
if (xp != null) {
xp.red = false;
if (xpp != null) {
xpp.red = true;
root = rotateLeft(root, xpp);
}
}
}
}
}
}上面的代码配合这三个图片，看出1-3 处理完后，刚好是图1-1 处理条件，向上递归，直到终止循环。这个就是插入后，调整红黑树平衡整体流程。这些代码，我当时看了一整天也明白什么意思，后面结合红黑树知识，自己画图对应代码流程，理解起来就很简单了。
有了这些理解在去看putTreeVal方法就很简单了
/**
* Tree version of putVal.
*/
final TreeNode<K,V> putTreeVal(HashMap<K,V> map, Node<K,V>[] tab,
int h, K k, V v) {
Class<?> kc = null;
boolean searched = false;
TreeNode<K,V> root = (parent != null) ? root() : this;
for (TreeNode<K,V> p = root;;) {
int dir, ph; K pk;
if ((ph = p.hash) > h)
dir = -1;
else if (ph < h)
dir = 1;
else if ((pk = p.key) == k || (k != null && k.equals(pk)))
return p;
// 获取key 类型，判断是是compare接口 比较大小
else if ((kc == null &&
(kc = comparableClassFor(k)) == null) ||
(dir = compareComparables(kc, k, pk)) == 0) {
if (!searched) {
TreeNode<K,V> q, ch;
searched = true;
if (((ch = p.left) != null &&
(q = ch.find(h, k, kc)) != null) ||
((ch = p.right) != null &&
(q = ch.find(h, k, kc)) != null))
return q;
}
dir = tieBreakOrder(k, pk); //使用类名，原生hash比较大小
}
TreeNode<K,V> xp = p;
if ((p = (dir <= 0) ? p.left : p.right) == null) {
Node<K,V> xpn = xp.next;
TreeNode<K,V> x = map.newTreeNode(h, k, v, xpn);
if (dir <= 0)
xp.left = x;
else
xp.right = x;
xp.next = x;
x.parent = x.prev = xp;
if (xpn != null)
((TreeNode<K,V>)xpn).prev = x;
moveRootToFront(tab, balanceInsertion(root, x));
return null;
}
}
}
遍历树链，比较hash 大小，找到子节点插入位置，使用balanceInsertion方法平衡红黑树。
获取value 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;
if ((tab = table) != null && (n = tab.length) > 0 && //空数组不指望了
(first = tab[(n - 1) & hash]) != null) { //计算数组下标位置
if (first.hash == hash && // 获取到value
((k = first.key) == key || (key != null && key.equals(k))))
return first;
if ((e = first.next) != null) {
if (first instanceof TreeNode) //使用红黑树查找
return ((TreeNode<K,V>)first).getTreeNode(hash, 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> root() {
for (TreeNode<K,V> r = this, p;;) {
if ((p = r.parent) == null)
return r;
r = p;
}
}
final TreeNode<K,V> find(int h, Object k, Class<?> kc) {
TreeNode<K,V> p = this;
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节点肯定没有字节点
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;
}删除节点
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;
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;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k)))) //根据key 找到value
node = p;
else if ((e = p.next) != null) {
if (p instanceof TreeNode)
node = ((TreeNode<K,V>)p).getTreeNode(hash, key); //使用红黑树寻找
else {
do { //链表遍历查找
if (e.hash == hash &&
((k = e.key) == key ||
(key != null && key.equals(k)))) {
node = e;
break;
}
p = e;
} while ((e = e.next) != null);
}
}
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) //如果p刚好是链头，指引删除
tab[index] = node.next;
else //p 刚好表示前一位，node 要被删除，p指向node 下一个节点，即可删除。
p.next = node.next;
++modCount;
--size;
afterNodeRemoval(node);
return node;
}
}
return null;
}数组和链表删除还是比较简单的，下标指引变更即可。红黑树元素删除就相当复杂了，比插入数据要麻烦等多了
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) //前置节点为空，将链头指向succ，即子节点
tab[index] = first = succ;
else //将前置节点指向next，相当于删除this
pred.next = succ;
if (succ != null) //删除
succ.prev = pred;
if (first == null)
return;
if (root.parent != null)
root = root.root();
if (root == null //根据红黑树特性，最短路径不能小于最长路径1/2，树链长度不足 2 +4 = 6，拆分
|| (movable
&& (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) // 找到右孩子的左子树找最小值
s = sl;
boolean c = s.red; s.red = p.red; p.red = c; // 交换颜色
TreeNode<K,V> sr = s.right;
TreeNode<K,V> pp = p.parent;
if (s == pr) { // s 是 p直系右子节点 ，交换位置
p.parent = s;
s.right = p;
}
else {
TreeNode<K,V> sp = s.parent;
if ((p.parent = sp) != null) { //p 移动到s 位置
if (s == sp.left)
sp.left = p;
else
sp.right = p;
}
if ((s.right = pr) != null) //s 移动到位置
pr.parent = s;
}
p.left = null;
if ((p.right = sr) != null) //p 右节点 和s 关联
sr.parent = p;
if ((s.left = pl) != null) //s 和p子左边节点pl关联起来
pl.parent = s;
if ((s.parent = pp) == null) // s 父节点 指向 p 父节点 s 已经完全替换p
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).red = false;
else if (p == pp.left)
pp.left = replacement;
else
pp.right = replacement;
p.left = p.right = p.parent = null;
}
//调整元素在红黑树中着色，保持平衡
TreeNode<K,V> r = p.red ? root : balanceDeletion(root, replacement);
if (replacement == p) { // 删除元素p
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);
}简单说一下，这个方法代码是思路，首先处理最简单的链表删除元素，将链表中对象的引用改成旁边的元素。
红黑树删除元素则比较复杂点，考虑的情况比较多。比如删除节点在底下，没有子节点，还要考虑元素的着手，如果是红色则可以直接删除，黑色需要着色。如果拥有一个左节点、右节点或者两个都要，情况就更加复杂了。这个方法大部分代码都是在处理左右节点不为空的情况，将删除节点位置和右节点下最左边的子节点交换位置，并且交换着色。为什么要这么做呢？主要是因为这个节点的hash值和删除节点值最为接近，红黑树的特性小于在左边，大于在右边，大于删除值的最小值，就整个红黑树最接近删除的值。在调整红黑树着色，任务就算完成了。
心得
整体来说HashMap的代码并不是很复杂，底层业务代码，其实就跟我们平常写的crud代码。但是我在看代码的时候，有一些地方好难看懂啊，主要是涉及到红黑树的知识点。很多程序员（包括我）平常都会抱怨数据结构没什么用，在工作中用不上，其实我们掌握不够熟练，在工作上不知道使用。
java
**粗体** _斜体_ [链接](http://example.com) `代码` - 列表 > 引用。你还可以使用@来通知其他用户。