一.什么是HashMap
一·特性
HashMap基于Map接口实现，元素以键值对的方式存储，允许键和值为null，因为key不允许重复，因此只能有一个键为null。它是无序的。HashMap是线程不安全的。
二.jdk1.7
一.数据结构
jdk1.7hashmap是一个“链表散列”的数据结构，数组+单向链表。
Entry类是一个HashMap的静态内部类。
static class Entry<K,V> implements Map.Entry<K,V> {
final K key;
V value;
Entry<K,V> next;//存储指向下一个Entry的引用，单链表结构
int hash;//对key的hashcode值进行hash运算后得到的值，存储在Entry，避免重复计算
/**
* 创建一个新Entry，并用新的节点指向链表的头结点。
*/
Entry(int h, K k, V v, Entry<K,V> n) {
value = v;
next = n;
key = k;
hash = h;
}
二.属性
//默认初始化化容量16，1左移4位即16。可以通过构造方法进行自定义。
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
//最大容量，即2的30次方
static final int MAXIMUM_CAPACITY = 1 << 30;
//默认装载因子0.75，作用在于，当存储的容量超过阈值（存储容量和加载因子的乘积）时，要对哈希表进行扩展操作。
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//HashMap内部的存储结构是一个数组，此处数组为空，即没有初始化之前的状态
static final Entry<?,?>[] EMPTY_TABLE = {};
//空的存储实体
transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;
//实际存储的键值对的个数
transient int size;
//实际数组容量 也叫扩容的阈值，size超过了threshold就会扩容，当table == {}时，该值为初始容量（初始容量默认为16）。
//阈值=容量*负载因子
int threshold;
//负载因子，代表了table的填充度有多少，默认是0.75
final float loadFactor;
//map结构修改次数，用于迭代器
transient int modCount;
//默认阈值
static final int ALTERNATIVE_HASHING_THRESHOLD_DEFAULT = Integer.MAX_VALUE;
//哈希种子(hashSeed)用于优化哈希函数，默认为0是不使用替代哈希算法
transient int hashSeed = 0;
//定义Map.Entry<K,V>集合。
private transient Set<Map.Entry<K,V>> entrySet = null;
1.为什么负载载因子是0.75 ？
源码分析：数组下标 = hash & (length-1)， 所以:
加载因子越大，内存利用率越高，index下标冲突概率也就越大；
加载因子越小，内存利用率越低，index下标冲突概率也就越小；
三.构造方法
//这个构造方法用于传入初始容量和扩容因子
public HashMap(int initialCapacity, float loadFactor) {
//传入的初始容量小于0，抛异常
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
//当初始容量大于最大容量时，使用最大容量
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
//判断加载因子必须是大于0,而且必须是数字
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
// 设置实际负载因子
this.loadFactor = loadFactor;
//设置扩容阀值=初始容量，但是在put()方法初始化数组时, 其实际值=容量*负载因子
threshold = initialCapacity;
init();
}
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
public HashMap() {
this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
}
//用于将一个Map存入这个map中
public HashMap(Map<? extends K, ? extends V> m) {
this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1,
DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);
inflateTable(threshold);
putAllForCreate(m);
}
小结：
1.当调运有参构造，赋予的初始容量传入的初始容量小于0，抛异常。
2.若赋予的初始容量大于最大容量时，使用最大容量 。
四.put()方法
public V put(K key, V value) {
// 判断数组是否为空
if (table == EMPTY_TABLE) {
// 初始化数组方法
inflateTable(threshold);
}
// 判断添加的key是否null
if (key == null)
return putForNullKey(value); // 如果为null, 则对应的value存放到table[0]
// 根据key计算哈希值
int hash = hash(key);
// 计算数组下标 i= hash & (length - 1)
int i = indexFor(hash, table.length);
// 获取相同hashCode对应下标的table[i]数据, 并遍历
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
// 判断hashcode相同并且key值相同
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
// 如果为true,表示key一同，覆盖
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
modCount++; //实际修改次数加1
// 如果hash不同 或者 hansh相同对象不同， 则添加元素
addEntry(hash, key, value, i);
return null;
}
//key为null的值，默认hashcode为0，放在哈希桶的第一个位置
private V putForNullKey(V value) {
//如果多次put key为null的键值对，新值会覆盖原来的值
for (Entry<K,V> e = table[0]; e != null; e = e.next) {
if (e.key == null) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
modCount++;
//这里默认位置为第一个
addEntry(0, null, value, 0);
return null;
}
// 初始化hash表
private void inflateTable(int toSize) {
// Find a power of 2 >= toSize
//就是找到一个数，数是2的幂次方并且大于等于toSize，比如传入的数是13，14或15，那么初始容量就是16
int capacity = roundUpToPowerOf2(toSize);
// 重新记录阈值，阈值=容量* 扩容因子
threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
table = new Entry[capacity];
initHashSeedAsNeeded(capacity);
}
// 添加entry对象
void addEntry(int hash, K key, V value, int bucketIndex) { // bucketIndex数组下标
// 判断的数组的大小是否大于等于阀值
if ((size >= threshold) && (null != table[bucketIndex])) {
// 扩容后数组长度为之前的2倍
resize(2 * table.length);
// 扩容后重新计算下标
hash = (null != key) ? hash(key) : 0;
bucketIndex = indexFor(hash, table.length);
}
//若容量足够，则创建1个新的数组元素（Entry） 并放入到数组中
createEntry(hash, key, value, bucketIndex);
}
// 创建Entry对象
void createEntry(int hash, K key, V value, int bucketIndex) {
// 获取原来的oldEntry对象, 如果!=null表示发生hash冲突
Entry<K,V> e = table[bucketIndex];
// 创建新的newEntry对象 并且将新对象作为链表的头结点
table[bucketIndex] = new Entry<>(hash, key, value, e);
size++;
}
// 扩容数组
void resize(int newCapacity) {
// 保存旧数组
Entry[] oldTable = table;
int oldCapacity = oldTable.length;
// 如果数组达到最大容量，return
if (oldCapacity == MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return;
}
// 创建一个新的数组，newCapacity=2 * table.length
Entry[] newTable = new Entry[newCapacity];
// 将旧数组的内容转换到新的数组中
transfer(newTable, initHashSeedAsNeeded(newCapacity));
table = newTable;
// 重新计算阀值
threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
}
//使我们的hash算法变得更复杂一些，也就是更散列一些，均匀分布，减少hash冲突
final boolean initHashSeedAsNeeded(int capacity) {
boolean currentAltHashing = hashSeed != 0;
boolean useAltHashing = sun.misc.VM.isBooted() &&
(capacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);
boolean switching = currentAltHashing ^ useAltHashing;
if (switching) {
hashSeed = useAltHashing
? sun.misc.Hashing.randomHashSeed(this)
: 0;
}
return switching;
}
//将旧表转移到新表中
void transfer(Entry[] newTable, boolean rehash) {
int newCapacity = newTable.length;
//变量旧table
for (Entry<K,V> e : table) {
//按旧链表的正序遍历链表
while(null != e) {
//保存旧的哈希表对应的链表头的下一个结点
Entry<K,V> next = e.next;
//重新计算hash值
if (rehash) {
e.hash = null == e.key ? 0 : hash(e.key);
}
//重新计算索引
int i = indexFor(e.hash, newCapacity);
//将newTable[i]上的Entry对象（第一次循环null），赋值给当前结点的下一个元素，妙！
e.next = newTable[i];
//将结点赋值到新的哈希表
newTable[i] = e;
e = next;
}
}
}
private static int roundUpToPowerOf2(int number) {
return number >= MAXIMUM_CAPACITY
? MAXIMUM_CAPACITY
: (number > 1) ? Integer.highestOneBit((number - 1) << 1) : 1;
}
//计算key的hash值
final int hash(Object k) {
int h = hashSeed;
if (0 != h && k instanceof String) {
return sun.misc.Hashing.stringHash32((String) k);
}
h ^= k.hashCode();
//一般的hashcode高位都是0，为尽量避免hash冲突，进行扰动处理。
h ^= (h >>> 20) ^ (h >>> 12);
return h ^ (h >>> 7) ^ (h >>> 4);
}
//对table数组长度取模，计算索引
static int indexFor(int h, int length) {
return h & (length-1);
}
小结：
1.hash表是第一次调用put时初始化的，默认容量是16。如果自定义了，也一定是2的n次方，因为要进行容量与hash值取模，获取索引。
2.添加元素，是通过元素hashcode与数组容量取模获取索引的。
3.为均分分布和尽量避免hash冲突，取索引时采用了动扰函数处理。
4.当key为null时，在hash表索引0处。
5.当key重复，新值会覆盖旧值。
6.当传入的初始容量不是2的幂，会取这个值最近的2的幂的值，如传入13，容量会是16。
7.当数组容量到达阈值，会进行扩容，是原来的2倍。
8.扩容会进行rehash，重新计算索引，并进行hash复杂化，使之分布更均匀。
9.如果产生hash冲突，采用链表的方法。
10.hash表中的链表是采用头插的方式。
五.get()方法
public V get(Object key) {
// 判断key是否为null
if (key == null) {
return getForNullKey(); //去table[0]取值
}
//不为null，通过key获取获取对应下标的数组
Entry<K,V> entry = getEntry(key);
return null == entry ? null : entry.getValue();
}
final Entry<K,V> getEntry(Object key) {
if (size == 0) {
return null;
}
// 根据key获取hashcode值
int hash = (key == null) ? 0 : hash(key);
// 通过indexFor()计算下标，然后在这个位置上循环单向链表。
for (Entry<K,V> e = table[indexFor(hash, table.length)]; e != null; e = e.next) {
Object k;
//取得table中hash值一样且key一样的Entity
if (e.hash == hash &&((k = e.key) == key || (key != null && key.equals(k))))
return e;
}
return null;
}
小结：
1.通过key的hash值与容量取模计算出索引，取出元素。
六.remove()方法
public V remove(Object key) {
Entry<K,V> e = removeEntryForKey(key);
return (e == null ? null : e.value);
}
final Entry<K,V> removeEntryForKey(Object key) {
//如果数组为空，直接返回。
if (size == 0) {
return null;
}
//根据key删除元素,然后再通过indexFor得到要删除的元素所在的位置。
//然后循环，找到要删除元素的key，这里删除使用的是链表出队的方式。
int hash = (key == null) ? 0 : hash(key);
int i = indexFor(hash, table.length);
Entry<K,V> prev = table[i];
Entry<K,V> e = prev;
while (e != null) {
Entry<K,V> next = e.next;
Object k;
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k)))) {
modCount++;
size--;
//说明不在链表上，删除的是第一个节点
if (prev == e)
table[i] = next;
//说明是删除的是中间节点，删除一个节点A只需要让上一个节点B的next指向节点C即可
else
prev.next = next;
e.recordRemoval(this);
return e;
}
//指向下一个节点，继续循环查找
prev = e;
e = next;
}
return e;
}
七.迭代器
EntrySet 是HashMap中的一个内部类，以Set类型用于保存hash表键值对。
private final class EntrySet extends AbstractSet<Map.Entry<K,V>> {
public Iterator<Map.Entry<K,V>> iterator() {
return newEntryIterator(); // 创建迭代器
}
public boolean contains(Object o) {
if (!(o instanceof Map.Entry)) // 比较类型
return false;
Map.Entry<K,V> e = (Map.Entry<K,V>) o;
Entry<K,V> candidate = getEntry(e.getKey());
return candidate != null && candidate.equals(e);
}
public boolean remove(Object o) {
return removeMapping(o) != null;
}
public int size() {
return size;
}
public void clear() {
HashMap.this.clear();
}
}
public Set<Map.Entry<K,V>> entrySet() {
return entrySet0();
}
private Set<Map.Entry<K,V>> entrySet0() {
Set<Map.Entry<K,V>> es = entrySet;
return es != null ? es : (entrySet = new EntrySet()); // entrySet为空时创建一个EntrySet对象
}
HashMap内部有三种迭代器
private final class ValueIterator extends HashIterator<V> {
public V next() {
return nextEntry().value;
}
}
private final class KeyIterator extends HashIterator<K> {
public K next() {
return nextEntry().getKey();
}
}
private final class EntryIterator extends HashIterator<Map.Entry<K,V>> {
public Map.Entry<K,V> next() {
return nextEntry();
}
}
真正的迭代器
// hash迭代器
private abstract class HashIterator<E> implements Iterator<E> {
Entry<K,V> next; // next entry to return
int expectedModCount; // For fast-fail
int index; // current slot
Entry<K,V> current; // current entry
HashIterator() {
expectedModCount = modCount; // 临时存储
if (size > 0) { // advance to first entry
Entry[] t = table;
while (index < t.length && (next = t[index++]) == null)
;
}
}
public final boolean hasNext() {
return next != null;
}
// 每次迭代都会调用次函数得到下一个Entry对象
final Entry<K,V> nextEntry() {
//如果实际修改次数和预期修改次数不一致，抛异常。
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
Entry<K,V> e = next;
if (e == null)
throw new NoSuchElementException();
if ((next = e.next) == null) {
Entry[] t = table;
while (index < t.length && (next = t[index++]) == null)
;
}
current = e;
return e;
}
public void remove() {
if (current == null)
throw new IllegalStateException();
if (modCount != expectedModCount) // 判断
throw new ConcurrentModificationException();
Object k = current.key;
current = null;
HashMap.this.removeEntryForKey(k);
expectedModCount = modCount;
}
}
获取方法，见名知意，分别可以迭代不同的东西。
Iterator<K> newKeyIterator() {
return new KeyIterator();
}
Iterator<V> newValueIterator() {
return new ValueIterator();
}
Iterator<Map.Entry<K,V>> newEntryIterator() {
return new EntryIterator();
}
八.jdk1.7头插造成死循环
一.死循环
死循环是多线程情况下数组扩容链表头插，引起的单链表循环指向。扩容会rehash重新定位元素的下标，并采用头插法迁移到新数组中。因为是头插，所以会将链表顺序反转，这是造成死循环的根本原因。
二.情景再现
正常扩容后
三.多线程下扩容
现在有线程A和线程B进行扩容，先看扩容关键方法
1.e=D，next=A时，线程A在该处挂起
此时线程A:
新数组索引0处为E，此时e=D，next=A，而该轮循环A.next=B。在元素D即将插入索引2处时，cup执行权被线程B抢。
2.线程B抢到cpu执行权，并正常扩容，并将新数组赋值给table。
由于线程B完成扩容并将自己线程的工作空间内的新数组刷回到主空间HashMap中。此时的主空间HashMap就是B线程扩容后的HashMap。
3.随后线程A获取到了cpu执行权，继续执行newTable[i] = e。此时线程A继续完成该轮循环。
继续执行该轮循环将D完成迁移。
4.然后线程A执行，此时e=A，next=B。
线程A继续执行：
5.由于线程B已经将扩容好的新数组刷回了主空间，然后e=B，next=A。
如果多个线程出现死循环，可以会造成cpu占满100%。
三.jdk1.8
改动：jdk1.8的hashmap有很大的优化，如数据结构：数组+链表+红黑树，为解决1.7链表死循环问题，使用了头插的方法。
一.数据结构
一.红黑树规则
1.每个节点是红色或黑色
2.根节点必须是黑色
3.一个节点没有子节点或者父节点，则该节点的指定属性值为Nil，就是叶节点，是黑色的。
4.红色节点的子节点必须是黑色的，且不能连续。
5.每个节点到它后代叶节点的简单路径上，包含相同数目的黑色节点。
6.树的最高层和最低层相差不能超过1，否则会进行自旋调整。
二.HashMap静态内部类Node
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;
}
}
三.HashMap静态内部类TreeNode
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
TreeNode<K,V> parent; //父节点地址
TreeNode<K,V> left; //左子节点地址
TreeNode<K,V> right; //右子节点的地址
TreeNode<K,V> prev; //前方节点地址，删除后需要取消链接
boolean red; //颜色
TreeNode(int hash, K key, V val, Node<K,V> next) {
super(hash, key, val, next);
}
}
//LinkedHashMap.Entry<K,V>的静态内部类Entry<K,V>,继承了HashMap的静态内部类Node<K,V>
static class Entry<K,V> extends HashMap.Node<K,V> {
Entry<K,V> before, after;
Entry(int hash, K key, V value, Node<K,V> next) {
super(hash, key, value, next);
}
}
小结：
1.TreeNode——继承——>LinkedHashMap.Entry——继承——>HashMap.Node。
2.从继承可知：转为红黑树节点后，链表的结构还存在，通过 next 属性维持，红黑树节点在进行操作时都会维护链表的结构。
二.属性
// 默认容量16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
// 最大的容量int型32位
static final int MAXIMUM_CAPACITY = 1 << 30;
// 默认负载因子0.75
static final float DEFAULT_LOAD_FACTOR = 0.75f;
// 链表转红黑树节点的阈值, 至少8个节点
static final int TREEIFY_THRESHOLD = 8;
// 红黑树转链表的阈值, 最多6个节点
static final int UNTREEIFY_THRESHOLD = 6;
// 转红黑树时, table的最小长度，避免调整大小和树化阈值之间发生冲突。
static final int MIN_TREEIFY_CAPACITY = 64;
/* ---------------- Fields -------------- */
//hash表：在第一次使用时初始化，并根据需要调整大小。 分配时，长度始终是 2 的幂
transient Node<K,V>[] table;
//保存缓存的 entrySet()
transient Set<Map.Entry<K,V>> entrySet;
//此映射中包含的键值映射数
transient int size;
//实际修改次数，用于检测并发修改异常
transient int modCount;
//阈值=（容量 * 负载因子）
int threshold;
//hash表的负载因子
final float loadFactor;
三.hash优化及索引计算
一.hash优化
//将key.hashcode的高位右移16位，形成高低位异或运算，增强散列性。
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
二.索引计算
hash表索引是通过table长度和优化过得hash值做与运算计算出。
n = tab.length
tab[i = (n - 1) & hash]
四.构造方法
public HashMap(int initialCapacity, float loadFactor) {
//如果初始容量<0，抛异常
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
//如果初始容量>最大容量，则初始容量=最大容量int型32位
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
//如果负载因子<=0或者非数字，抛异常
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
//初始化负载因子
this.loadFactor = loadFactor;
//初始化阈值
this.threshold = tableSizeFor(initialCapacity);
}
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
//map迁移
public HashMap(Map<? extends K, ? extends V> m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
// 将传入的子Map中的全部元素逐个添加到HashMap中
putMapEntries(m, false);
}
//返回给定目标容量的二次幂
static final int tableSizeFor(int cap) {
int n = -1 >>> Integer.numberOfLeadingZeros(cap - 1);
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}
五.put()方法
一.put()
public V put(K key, V value) {
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;
// 1.如果table为空或length==0，则调用resize方法初始化hash表
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
// 2.通过key的hash值计算索引，将该索引位置的头节点赋值给p，如果p==null，则在该索引位置创建节点
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
// table表该索引位置不为空，循环比对
Node<K,V> e; K k;
// 3.如果p节点的key和hash值跟传入的相等, 则将p节点赋值给e节点
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
// 4.如果p节点是TreeNode, 是则调用红黑树的putTreeVal方法查找节点
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
// 不是TreeNode，是普通链表Node节点，则调用链表方法进行查找节点，使用binCount统计链表长度
for (int binCount = 0; ; ++binCount) {
// 6.判断且将p.next赋值给e，如果不为空，则插入到尾部
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
// 7.p.next不为空，如果节点数超过8，则调用链表节点转为红黑树节点treeifyBin方法
if (binCount >= TREEIFY_THRESHOLD - 1)
treeifyBin(tab, hash);
break;
}
// 8.如果e节点存在hash值和key值都与传入的相同，则e节点即为目标节点，跳出循环
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e; // 将p指向下一个节点
}
}
// 9.如果e节点不为空，则代表目标节点存在，将新value覆盖该节点的value，并返回oldValue
if (e != null) {
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e); // 用于LinkedHashMap
return oldValue;
}
}
//修改值++
++modCount;
// 10.如果插入节点后节点数超过阈值，调用resize方法扩容
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
二.putTreeVal
红黑树节点TreeNode对象的put方法
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;
// 1.如果该节点的parent节点不为null，则调用root()查找根节点,因为索引位置不一定是红黑树root节点
TreeNode<K,V> root = (parent != null) ? root() : this;
// 2.从root节点开始进行查找
for (TreeNode<K,V> p = root;;) {
int dir, ph; K pk;
// 3.将该节点hash赋值给ph，如果该节点hash值大于传入的hash值，dir==-1，从该节点的左子节点查找
if ((ph = p.hash) > h)
dir = -1;
// 4.如果该节点hash值小于传入的hash值，dir==1，从该节点的右子节点查找
else if (ph < h)
dir = 1;
// 5.到这里，hash相等，将该节点的key赋值给pk，如果该节点key等于传入的key；则p节点为目标节点，返回p节点
else if ((pk = p.key) == k || (k != null && k.equals(pk)))
return p;
// 6.到这里，hash相等，key不相等。如果key没有实现Comparable接口，或者k和p节点的key相等
else if ((kc == null &&
(kc = comparableClassFor(k)) == null) ||
(dir = compareComparables(kc, k, pk)) == 0) {
// 6.1到这里，说明hash一样，key不一定一样。
if (!searched) {
TreeNode<K,V> q, ch;
//设置为true，那下次循环不能进入这个条件
searched = true;
//分别从p点左子节点和右子节点开始查找，只找一次，找到了直接返回
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;
}
//6.2 没找到，使用定义的一套规则来比较k和p节点的key的大小, 决定向左还是向右查找，k<pk则dir<0，向左
dir = tieBreakOrder(k, pk);
}
// 将p节点赋值给xp，用于给x的父节点赋值
TreeNode<K,V> xp = p;
// 7.dir<=0则向p左边查找,p==p.left,否则p==p.right。如果p左右节点为null，那么p点位置即x的目标位置
if ((p = (dir <= 0) ? p.left : p.right) == null) {
Node<K,V> xpn = xp.next; // xp的next节点
// 8.创建新的节点, 插入到xp节点和xp.next节点之间，并赋值给x，x.next为xpn
TreeNode<K,V> x = map.newTreeNode(h, k, v, xpn);
// 9.调整x、xp、xpn之间的属性关系
//如果时dir <= 0, 则代表x节点为xp的左节点
if (dir <= 0)
xp.left = x;
// 否则代表x节点为xp的右节点
else
xp.right = x;
xp.next = x; // 将xp的next节点设置为x
x.parent = x.prev = xp; // 将x的parent和prev节点设置为xp
// 如果xpn不为空,则将xpn的prev节点设置为x节点
if (xpn != null)
((TreeNode<K,V>)xpn).prev = x;
// 10.红黑树的平衡调整方法
moveRootToFront(tab, balanceInsertion(root, x));
return null;
}
}
}
三.treeifyBin
/**
* 链表节点转为红黑树节点
*/
final void treeifyBin(Node<K,V>[] tab, int hash) {
int n, index; Node<K,V> e;
// 1.如果table为空或者table的长度小于64, 调用resize方法进行扩容
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
resize();
// 2.根据hash值计算索引，将该索引位置节点赋值给e，从e开始遍历该索引位置的链表
else if ((e = tab[index = (n - 1) & hash]) != null) {
TreeNode<K,V> hd = null, tl = null;
do {
// 3.将链表节点转为红黑树节点
TreeNode<K,V> p = replacementTreeNode(e, null);
// 4.tl==null，将头节点赋值给hd，预示着只有第一次遍历才执行
if (tl == null)
hd = p;
else {
// 5.否则处理当前节点p的prev属性设为上一个节点tl，tl的下一个节点设为p
p.prev = tl;
tl.next = p;
}
// 6.将p节点赋值给tl，用于在下一次循环中作为上一个节点进行一些链表的关联操作
tl = p;
} while ((e = e.next) != null);
// 7.将table该索引位置赋值为新转的TreeNode的头节点，如果该节点不为空，则以以头节点hd为根节点构建红黑树
if ((tab[index] = hd) != null)
hd.treeify(tab);
}
}
四.treeify
TreeNode对象构建红黑树方法
final void treeify(Node<K,V>[] tab) {
TreeNode<K,V> root = null;
// 1.将调用此方法的节点赋值给x，从x开始进行遍历
for (TreeNode<K,V> x = this, next; x != null; x = next) {
next = (TreeNode<K,V>)x.next; //将x的下个节点赋值给next
x.left = x.right = null; //将x的左右子节点设置为空
// 2.如果root节点为空, 则将x设置为根节点
if (root == null) {
x.parent = null; // 根节点的父节点设为null
x.red = false; // 根节点必须为黑色
root = x; // 将x设为根节点
}
//如果根节点不为空
else {
K k = x.key; // 将x的key赋值给k
int h = x.hash; // 将x的hash值赋值给h
Class<?> kc = null;
// 3.那么当前节点x不是根节点, 则从根节点开始查找属于该节点的位置
for (TreeNode<K,V> p = root;;) {
int dir, ph;
K pk = p.key;
// 4.如果x节点的hash值小于p节点的hash值，则将dir赋值为-1, 向p的左边查找
if ((ph = p.hash) > h)
dir = -1;
// 5.否则向p的右边查找
else if (ph < h)
dir = 1;
// 6.到这里，hash相等，key不相等。如果key没有实现Comparable接口，或者k和p节点的key相等
else if ((kc == null &&
(kc = comparableClassFor(k)) == null) ||
(dir = compareComparables(kc, k, pk)) == 0)
// 6.1 使用定义的一套规则来比较x节点和p节点的大小，决定向左或向右查找
dir = tieBreakOrder(k, pk);
// 将p节点赋值给xp，用于给x的父节点赋值
TreeNode<K,V> xp = p;
//7.dir<=0则向p左边查找,p==p.left,否则p==p.right。如果p左右节点为null，那么p点位置即x的目标位置
if ((p = (dir <= 0) ? p.left : p.right) == null) {
// 8.x和xp节点的属性设置
x.parent = xp; // 将xp赋值给x的父节点即为最后一次遍历的p节点
if (dir <= 0) // 如果时dir <= 0, 则代表x节点为父节点的左节点
xp.left = x;
else // 否则代表x节点为父节点的右节点
xp.right = x;
// 9.进行红黑树的插入平衡调整，使用左右旋和颜色调整
root = balanceInsertion(root, x);
break;
}
}
}
}
// 10.用于将root节点调整为table索引位置为头节点的方法
moveRootToFront(tab, root);
}
五.moveRootToFront
是TreeNode对象的方法，TreeNode在增加或删除节点后，都需要对整个树重新进行平衡调整，平衡之后的根节点可能发生变化，为了保证hash表数组下标取得的元素是一个TreeNode类型，那么这个TreeNode节点一定要是这颗树的根节点，同时也要是整个链表的首节点。
//确保给定的根是其 bin 的第一个节点。
static <K,V> void moveRootToFront(Node<K,V>[] tab, TreeNode<K,V> root) {
int n;
// 根节点不为空 并且table不为空
if (root != null && tab != null && (n = tab.length) > 0) {
//根据hash值得到root的索引
int index = (n - 1) & root.hash;
// 取得该位置上的第一个节点对象，并赋值给first
TreeNode<K,V> first = (TreeNode<K,V>)tab[index];
// 如果root所所在索引处table[index]不是root对象
if (root != first) {
Node<K,V> rn;
tab[index] = root; // 把数组index位置的元素替换为根节点对象
TreeNode<K,V> rp = root.prev; // 获取根节点对象的前一个节点，赋值给rp
if ((rn = root.next) != null) // 将root的下一个节点赋值给rn，如果rn不为null
((TreeNode<K,V>)rn).prev = rp; //root后节点的前节点 指向到 root的前节点，相当于把root从链表移除
if (rp != null) // 如果root的前节点不为空
rp.next = rn; // root前节点的后节点 指向到 root的后节点
if (first != null) // 如果数组该位置上原来的元素不为空
first.prev = root; // 这个原有的元素的 前节点 指向到 root，相当于root目前位于链表的首位
root.next = first; // 原来的第一个节点现在作为root的下一个节点，变成了第二个节点
root.prev = null; // 首节点没有前节点
}
//校验TreeNode对象是否满足红黑树和双链表的特性,防止结构被破坏
assert checkInvariants(root);
}
}
六.afterNodeAccess
这个方法是LinkedHashMap的方法，当 removeEldestEntry() 方法返回 true 时会移除最晚的节点，也就是链表首部节点 first。
void afterNodeInsertion(boolean evict) { // possibly remove eldest
LinkedHashMap.Entry<K,V> first;
if (evict && (first = head) != null && removeEldestEntry(first)) {
K key = first.key;
removeNode(hash(key), key, null, false, true);
}
}
/**
*removeEldestEntry() 默认为 false，如果需要让它为 true，需要继承 LinkedHashMap 并且覆盖这个方法的实现，
* 这在实现 LRU 的缓存中特别有用，通过移除最近最久未使用的节点，从而保证缓存空间足够，并且缓存的数据都是热点
* 数据。
*/
protected boolean removeEldestEntry(Map.Entry<K,V> eldest) {
return false;
}
七.resize
初始化或加倍表大小。 如果为空，则根据字段阈值中持有的初始容量目标进行分配。 否则，因为我们使用的是 2 的幂扩展，所以每个 bin 中的元素必须保持相同的索引，或者在新表中以 2 的幂的偏移量移动。
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
// 1.旧表容量不为空操作
if (oldCap > 0) {
// 如果旧表容量超过最大容量，并直接返回旧表
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
// 1.1 将newCap赋值为oldCap的2倍，如果newCap<最大容量并且oldCap>=16, 则将新阈值设置为原来的两倍
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
// 2.如果旧的容量为0, 且旧表的阈值大于0，则将新表的容量设置为旧表的阈值
else if (oldThr > 0)
newCap = oldThr;
else {
// 3.旧表的容量为0, 且老表的阈值为0，将新表阈值和容量设置为默认值
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
// 4.如果新表的阈值为空, 则通过新的容量*负载因子获得阈值
if (newThr == 0) {
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
// 5.将当前阈值设置为刚计算出来的新的阈值，将table设置为新定义的表。
threshold = newThr;
@SuppressWarnings({"rawtypes","unchecked"})
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
// 6.如果旧表不为空，则遍历所有节点，将节点迁移给新表
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) { // 将索引值为j的旧表头节点赋值给e
oldTab[j] = null; // 将旧表的j索引处设置为空,便于回收
// 7.如果e.next为空,则旧表该索引处只有一个节点，将该节点赋值给新表的新计算出的索引处
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;
// 8.如果是红黑树节点，则进行红黑树的rehash分布
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // preserve order
// 9.如果是普通的链表节点，则进行链表的rehash分布
Node<K,V> loHead = null, loTail = null;//存储在原索引处
Node<K,V> hiHead = null, hiTail = null;//存储在原索引+oldcap处
Node<K,V> next;
do {
next = e.next;
// 9.1 如果e的hash值与旧表的容量进行与运算为0,则扩容后的索引位置跟旧表的索引位置相同
if ((e.hash & oldCap) == 0) {
if (loTail == null) // 如果loTail为空, 代表该节点为第一个节点
loHead = e; //将e节点赋值给头节点
else
loTail.next = e; // 否则将节点添加在loTail后面
loTail = e; // 并将loTail赋值为新增的节点
}
// 9.2否则扩容后的索引位置为:老表的索引位置＋oldCap
else {
if (hiTail == null) // 如果hiTail为空, 代表该节点为第一个节点
hiHead = e; // 将hiHead赋值为第一个节点
else
hiTail.next = e; // 否则将节点添加在hiTail后面
hiTail = e; // 并将hiTail赋值为新增的节点
}
} while ((e = next) != null);
// 10.如果loTail不为空说明新表有数据分布了，则将最后一个节点的next设为空，并将头结点设置到原索引位置
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
// 11.如果hiTail不为空说明旧表有数据分布到新表[原索引+oldcap]位置，则将最后一个节点的next设为
//null，并将新表[原索引+oldCap]节点设置为对应的头节点
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
八.split
红黑树的分割方法，将树箱中的节点拆分为下树箱和上树箱，或者如果现在太小则取消树化。
final void split(HashMap<K,V> map, Node<K,V>[] tab, int index, int bit) {
TreeNode<K,V> b = this; // this是调用此方法的节点，赋值给b
TreeNode<K,V> loHead = null, loTail = null; //低位首节点和低位尾节点，存储索引位置为:原索引位置
TreeNode<K,V> hiHead = null, hiTail = null; //高位首节点和高位尾节点，存储索引位置为:原索引+oldCap
//用于检验红黑树退化的变量
int lc = 0, hc = 0;
// 1.b节点开始，遍历整个红黑树节点
for (TreeNode<K,V> e = b, next; e != null; e = next) {
next = (TreeNode<K,V>)e.next; //将e的下一个节点赋值给next
e.next = null; //同时设置为空，以便GC
// 2.e的hash值与旧表的容量做与运算为0,则扩容后在新表的位置和原来在旧表的位置一样
if ((e.hash & bit) == 0) {
// 将低位尾节点赋值给e的prev节点，同时如果低位尾节点为空, 代表该节点为第一个节点
if ((e.prev = loTail) == null)
loHead = e; // 让loHead成为第一个节点
else
loTail.next = e; // loTail节点不为null，将e节点添加在loTail后面
loTail = e; //将e节点赋值给loTail节点
++lc; // 统计低位链表（原索引）下的节点个数
}
// 3.e的hash值与旧表的容量做与运算非0,则扩容后的索引位置为旧表的索引＋oldCap位置
else {
if ((e.prev = hiTail) == null) // 如果hiHead为空, 代表该节点为第一个节点
hiHead = e; // 让hiHead成为第一个节点
else
hiTail.next = e; //将e节点添加在hiTail后面
hiTail = e; // 并将hiTail赋值为新增的节点
++hc; // 统计高位链表（原索引+oldCap）下的节点个数
}
}
// 4.如果低位链表首节点不为null，说明有这个链表存在
if (loHead != null) {
// 4.1 如果节点个数<=6个则将红黑树转为链表结构
if (lc <= UNTREEIFY_THRESHOLD)
//树退化方法，低位链表，迁移到新数组中下标不变
tab[index] = loHead.untreeify(map);
else {
// 4.2 将原索引位置的节点设置为对应的头节点
tab[index] = loHead;
// 4.3如果高位首节点不为空，说明原来的红黑树已经被拆分成两个链表，分散到新链表了
if (hiHead != null)
// 4.4 以loHead为根节点, 构建新的红黑树
loHead.treeify(tab);
}
}
// 5.如果高位链表首节点不为null，说明有这个链表存在
if (hiHead != null) {
// 5.1 如果链表下节点个数<=6个则将红黑树退化为链表结构
if (hc <= UNTREEIFY_THRESHOLD)
//高位链表，迁移到新数组中的下标[原索引+oldCap]
tab[index + bit] = hiHead.untreeify(map);
else {
// 5.2高位链表，迁移到新数组[原索引+oldCap]下，并设置为头节点
tab[index + bit] = hiHead;
// 5.3 果低位首节点不为空，说明原来的红黑树已经被拆分成两个链表了
// 已经被改变, 需要重新构建新的红黑树
if (loHead != null)
// 5.4 以hiHead为根节点, 构建新的红黑树
hiHead.treeify(tab);
}
}
}
九.untreeify
红黑树退化成链表的方法，当达到退化阈值时调用
final Node<K,V> untreeify(HashMap<K,V> map) {
//hd 链表头节点
//tl 链表尾节点
Node<K,V> hd = null, tl = null;
// 1.从调用该方法的TreeNode节点p,从头节点开始遍历, 将所有节点全转为链表节点
for (Node<K,V> q = this; q != null; q = q.next) {
// 2.构建链表节点
Node<K,V> p = map.replacementNode(q, null);
// 3.如果tl为null, 则代表当前节点为第一个节点, 赋值给hd节点
if (tl == null)
hd = p;
// 4.如果tl节点不为空，则将tl的后节点指向p
else
tl.next = p;
tl = p; // 5.将tl节点指向当前节点, 即尾节点
}
// 6.返回转换后的链表的头节点
return hd;
}
六.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;
//table不为null且容量大于0，通过寻址算法找到的索引下不为空
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
// 2.如果首节点的hash值符合，且key相等，则该节点就是目标节点
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
return first;
// 3.如果first不是目标节点，且first的next节点不为空则继续遍历
if ((e = first.next) != null) {
if (first instanceof TreeNode)
// 4.如果是红黑树节点，则调用红黑树的查找目标节点方法getTreeNode
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
do {
// 5.执行链表节点的查找，向下遍历链表, 直至找到目标节点
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
// 6.找不到符合的返回空
return null;
}
一.getTreeNode
final TreeNode<K,V> getTreeNode(int h, Object k) {
//找到红黑树的根节点,使用根节点调用find方法
return ((parent != null) ? root() : this).find(h, k, null);
}
二.find
使用给定的散列和键查找从根 p 开始的节点。 kc 参数在第一次使用比较键时缓存可比较ClassFor(key)。
final TreeNode<K,V> find(int h, Object k, Class<?> kc) {
// 1.将调用此方法的节点赋值给p，即为红黑树根节点
TreeNode<K,V> p = this;
// 2.从p节点开始向下遍历
do {
int ph, dir; K pk;
TreeNode<K,V> pl = p.left, pr = p.right, q;
// 3.如果p节点的hash值>传入的hash值，则往p节点的左子节点遍历
if ((ph = p.hash) > h)
p = pl;
else if (ph < h) // 4.如果p节点的hash值<传入的hash值，则往p节点的右子节点遍历
p = pr;
// 5.如果传入的hash值和key值等==p节点的hash值和key值,则p节点为目标节点,返回p节点
else if ((pk = p.key) == k || (k != null && k.equals(pk)))
return p;
// 6.p节点的左节点为空则将向右遍历
else if (pl == null)
p = pr;
//7.p节点的右节点为空则向左遍历
else if (pr == null)
p = pl;
// 8.都不为null，检验从哪开始寻找，kc不为空代表k实现了Comparable，k<pk则dir<0, k>pk则dir>0
else if ((kc != null ||
(kc = comparableClassFor(k)) != null) &&
(dir = compareComparables(kc, k, pk)) != 0)
// 8.1 k<pk则向左遍历, 否则向右遍历
p = (dir < 0) ? pl : pr;
// 9.key所属类没有实现Comparable, 向p的右边遍历
else if ((q = pr.find(h, k, kc)) != null)
return q;
// 10.往右找不到, 向左遍历
else
p = pl;
} while (p != null);
return null;
}
七.remove
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;
// 1.如果table不为null且根据寻址出来的索引位置不为空, 将该位置节点赋值给p
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;
// 2.如果p的hash值和key都与传入的相同, 则p为目标节点, 赋值给node
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
node = p;
// 3.否则将p.next赋值给e，向下遍历节点
else if ((e = p.next) != null) {
// 3.1 如果p是TreeNode则调用红黑树的方法查找节点
if (p instanceof TreeNode)
node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
else {
// 3.2 否则，普通链表节点的查找法
do {
// 当节点的hash值和key与传入的相同,则该节点为目标节点
if (e.hash == hash &&
((k = e.key) == key ||
(key != null && key.equals(k)))) {
node = e; // 将e赋值给node, 跳出循环
break;
}
p = e; //将e赋值给p，在下一次循环中，e为p的next节点
} while ((e = e.next) != null);
}
}
// 4.如果node不为空，即找到目标节点，则进行移除
if (node != null && (!matchValue || (v = node.value) == value ||
(value != null && value.equals(v)))) {
// 4.1 如果是TreeNode则调用红黑树的移除方法
if (node instanceof TreeNode)
((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
//4.2 node == p说明node是头节点，将该索引位置的值赋值为node的next节点
//如果node不是头节点，则node为p的next节点
else if (node == p)
tab[index] = node.next;
// 4.3 否则将node的上一个节点的next属性设置为node的next节点,就是链表的移除操作
else
p.next = node.next;
++modCount;
--size;
// LinkedHashMap使用方法，函数是在移除节点后调用的，就是将节点从双向链表中删除
afterNodeRemoval(node);
// 5.返回被移除的节点
return node;
}
}
return null;
}
一.removeTreeNode删除红黑树节点
删除给定节点，该节点必须在此调用之前存在。 这比典型的红黑删除代码更混乱，因为我们无法将内部节点的内容与叶后继交换，该后继由在遍历期间可独立访问的“下一个”指针固定。 因此，我们交换树链接。 如果当前树的节点似乎太少，则将 bin 转换回普通 bin。 （测试会在 2 到 6 个节点之间触发，具体取决于树结构）。
final void removeTreeNode(HashMap<K,V> map, Node<K,V>[] tab,
boolean movable) {
int n;
// 1.table为null或者length为0直接返回
if (tab == null || (n = tab.length) == 0)
return;
// 2.根据hash计算出索引
int index = (n - 1) & hash;
// 3.将索引位置的头节点赋值给first和root
//first-头节点，数组存放数据索引位置存在存放的节点值
//root-根节点,红黑树的根节点，正常情况下二者是相等的
//rl-root节点的左孩子节点,succ-后节点,pred-前节点
TreeNode<K,V> first = (TreeNode<K,V>)tab[index], root = first, rl;
// 4.将node的next节点赋值给succ节点，prev节点赋值给pred节点
TreeNode<K,V> succ = (TreeNode<K,V>)next, pred = prev;
// 5.如果pred节点为空，说明删除节点node为头节点，
if (pred == null)
tab[index] = first = succ;
else
// 6.否则将pred节点的next属性设置为succ节点
pred.next = succ;
// 7.如果succ节点不为空，则将succ的prev节点设置为pred
if (succ != null)
succ.prev = pred;
// 8.如果first节点为空，说明该节点删除后，红黑树为空，直接返回
if (first == null)
return;
// 9.如果root的父节点不为空, 则调用root方法重新获取当前树的根节点,将root赋值为根节点
if (root.parent != null)
root = root.root();
// 10.判断是否需要树退化
if (root == null || root.right == null ||
(rl = root.left) == null || rl.left == null) {
tab[index] = first.untreeify(map); // too small
return;
}
// 11.p为待删除节点，pl-待删除节点的左子节点，pr-待删除节点的右子节点，replacement-替换节点
TreeNode<K,V> p = this, pl = left, pr = right, replacement;
// 12.如果p的左节点和右节点都不为空时
if (pl != null && pr != null) {
// 12.1 将s节点赋值为p的右节点
TreeNode<K,V> s = pr, sl;
// 12.2 向左查找
while ((sl = s.left) != null)
s = sl;
// 12.3 互换后继节点和待删除节点的颜色
boolean c = s.red; s.red = p.red; p.red = c;
TreeNode<K,V> sr = s.right;//sr-后继节点的右孩子
TreeNode<K,V> pp = p.parent;// pp-待删除节点的父节点
// 12.4如果后继节点与当前节点的右子节点相等，待删除节点的右节点无左孩子
if (s == pr) {
p.parent = s;//右节点和待删除节点互换
s.right = p;
}
else {
//待删除节点的右节点有左孩子，将后继节点的父节点赋值给sp
TreeNode<K,V> sp = s.parent;
// 后继节点存在父节点，则让待删除节点替代后继节点
if ((p.parent = sp) != null) {
// 如果s节点为sp的左节点，则将sp的左节点赋值为p节点
if (s == sp.left)
sp.left = p;
// 否则s节点为sp的右节点，则将sp的右节点赋值为p节点
else
sp.right = p;
}
//
if ((s.right = pr) != null)
// 如果pr不为空，则将pr的父节点赋值为s
pr.parent = s;
}
//12.5修改当前节点和后继节点的孩子节点，当前节点现在变成后继节点了，故左孩子为null
p.left = null;
// 将p节点的右节点赋值为sr，如果不为null，则将sr的父节点赋值为p节点
if ((p.right = sr) != null)
sr.parent = p;
// 将s节点的左节点赋值为pl，如果不为null，则将pl的父节点赋值为s节点
if ((s.left = pl) != null)
pl.parent = s;
// 修改后继节点的父节点值，如果为null，说明后继节点现在变成了root节点
if ((s.parent = pp) == null)
root = s;
// 如果p不为root节点, 并且当前节点是其父节点的左孩子，则将pp的左节点赋值为s节点
else if (p == pp.left)
pp.left = s;
// 如果p不为root节点, 并且当前节点是其父节点的右孩子，则将pp的右节点赋值为s节点
else
pp.right = s;
// 12.6 sr-后继节点的右孩子节点不为空，删除节点后，替代节点就是其右孩子节点
if (sr != null)
replacement = sr;
// 12.6.1 如果sr为空，那么替代节点就是其本身，只需要将p节点直接去除即可
else
replacement = p;
}
// 13.如果p的左节点不为空，右节点为空，replacement节点为p的左节点作为替代节点
else if (pl != null)
replacement = pl;
// 14.如果p的右节点不为空,左节点为空，replacement节点为p的右节点作为替代节点
else if (pr != null)
replacement = pr;
// 15.如果p的左右节点都为空, 即p为叶子节点, replacement节点为p节点本身，直接删除当前节点
else
replacement = p;
// 16.如果删除节点存在两个孩子节点，最终与后继节点交换后，删除的节点的位置位于后继节点的位置
// 如果p节点不是叶子节点,替代节点不为待删除节点，则先进行节点删除，然后进行平衡调整
if (replacement != p) {
//将p节点的父节点赋值给replacement节点的父节点, 同时赋值给pp节点
TreeNode<K,V> pp = replacement.parent = p.parent;
//如果pp == null说明p没有父节点, 即p为root节点，则将root节点赋值为replacement节点
if (pp == null)
root = replacement;
//如果p不是root节点, 并且p为pp的左节点，则将pp的左节点赋值为替换节点replacement
else if (p == pp.left)
pp.left = replacement;
//如果p不是root节点, 并且p为pp的右节点，则将pp的右节点赋值为替换节点replacement
else
pp.right = replacement;
//p节点的位置已经被完整的替换为replacement, 节点的指向全部置NULL, 以便GC
p.left = p.right = p.parent = null;
}
// 17.如果删除的节点是红色则不会破坏红黑树的平衡无需调整，否则需要平衡调整
TreeNode<K,V> r = p.red ? root : balanceDeletion(root, replacement);
// 18.当 replacement == p 时，替代节点不为待删除节点，则先进行节点删除，然后进行平衡调整
if (replacement == p) {
//18.1将p的父节点赋值给pp
TreeNode<K,V> pp = p.parent;
//18.2将p的parent设置为null
p.parent = null;
//18.3如果父节点不为空，根据当前节点位于父节点的不同子节点，修改父节点的孩子节点值
if (pp != null) {
//如果p节点为父节点的左节点，则将父节点的左节点赋值为空
if (p == pp.left)
pp.left = null;
//如果p节点为父节点的右节点， 则将父节点的右节点设置为null
else if (p == pp.right)
pp.right = null;
}
}
if (movable)
// 19.将红黑树根节点root移到索引位置，置于链表的顶部
moveRootToFront(tab, r);
}
二.balanceDeletion
红黑树删除黑色节点后，平衡红黑树的方法
static <K, V> HashMap.TreeNode<K, V> balanceDeletion(HashMap.TreeNode<K, V> root, HashMap.TreeNode<K, V> x) {
//x 当前要删除的节点
//xp x节点的父节点
//xpl xp节点的左节点
//xpr xp节点的右节点
for (HashMap.TreeNode<K, V> xp, xpl, xpr; ; ) {
//当x == null，那么replacement == p ，删除节点不存在，返回
//当x == root，那么替代完成后，该节点就是整棵红黑树的根节点，是平衡的，返回
if (x == null || x == root)
return root;
// 如果父节点为空，那么当前节点是根节点，设置为黑色，返回
else if ((xp = x.parent) == null) {
x.red = false;
return x;
//被替换节点的颜色是红色的，替换成黑色的，达到平衡，返回
} else if (x.red) {
x.red = false;
return root;
//如果替换节点(父节点的左孩子)是黑色的,替换之前的节点也是黑色的,那么树黑色高度减少，需要平衡调整
} else if ((xpl = xp.left) == x) {
//父节点的右孩子为红色,且不为空，左旋平衡调整
if ((xpr = xp.right) != null && xpr.red) {
//兄弟节点变黑，父节点变红，以父节点为支点进行左旋
xpr.red = false;
xp.red = true;
root = rotateLeft(root, xp);
xpr = (xp = x.parent) == null ? null : xp.right;
}
// 兄弟节点为空，x指向父节点，向上调整
if (xpr == null)
x = xp;
else {
// sl兄弟节点的左子节点，sr兄弟节点的右子节点
HashMap.TreeNode<K, V> sl = xpr.left, sr = xpr.right;
//兄弟节点的右子节点为null（黑色），或者就是黑色。
//且，兄弟节点的左子节点为null(黑色)，或者本身就是黑色
if ((sr == null || !sr.red) && (sl == null || !sl.red)) {
//兄弟节点为红色，替换节点指向父节点
xpr.red = true;
x = xp;
} else {//到这，兄弟节点做左右至少一个是红色，可以连续两个黑色相连
//如果兄弟节点的右子节点为null（黑色），或者就是黑色。
if (sr == null || !sr.red) {
//处理方式：兄弟节点的左孩子设为黑色，兄弟节点设为红色，
//以兄弟节点为支点进行右旋，重新设置x的兄弟节点
if (sl != null)
sl.red = false;
xpr.red = true;
root = rotateRight(root, xpr);
xpr = (xp = x.parent) == null ? null : xp.right;
}
//兄弟节点的右孩子是红色
if (xpr != null) {
//如果兄弟节点存在，兄弟节点的颜色设置为父节点的颜色
//兄弟节点的右孩子存在，颜色设为黑色
//如果父节点存在，将父节点的颜色设为黑色,以父节点为支点进行左旋
xpr.red = (xp == null) ? false : xp.red;
if ((sr = xpr.right) != null)
sr.red = false;
}
// 父节点不为空，左旋平衡
if (xp != null) {
xp.red = false;
root = rotateLeft(root, xp);
}
// 替换节点指向根节点，平衡
x = root;
}
}
} else {
//替换节点是父节点的右孩子节点
if (xpl != null && xpl.red) {//兄弟节点存在且为红色
//兄弟节点变黑，父节点变红，以父节点为支点进行右旋，重新获取兄弟节点
xpl.red = false;
xp.red = true;
root = rotateRight(root, xp);
xpl = (xp = x.parent) == null ? null : xp.left;
}
// 兄弟节点为null，x指向父节点，向上调整
if (xpl == null)
x = xp;
else {
// sl兄弟节点的左子，sr兄弟节点的右子
HashMap.TreeNode<K, V> sl = xpl.left, sr = xpl.right;
//兄弟节点的左子不为null（黑色），或本身是黑色
//且，兄弟节点的右子不为null（黑色），或本身是黑色
if ((sl == null || !sl.red) && (sr == null || !sr.red)) {
//兄弟节点为红色，替换节点指向父节点
xpl.red = true;
x = xp;
} else {//兄弟节点左右至少一个是红色
if (sl == null || !sl.red) {//兄弟节点左子为null（黑色）
//兄弟右子不为null，那就是红色
if (sr != null)
//兄弟节点的右孩子设为黑色，兄弟节点设为红色，
//以兄弟节点为支点进行左，重新设置x的兄弟节点
sr.red = false;
xpl.red = true;
root = rotateLeft(root, xpl);
xpl = (xp = x.parent) == null ? null : xp.left;
}
//兄弟左子不为null，是红色
if (xpl != null) {
//如果兄弟节点存在，兄弟节点的颜色设置为父节点的颜色
xpl.red = (xp == null) ? false : xp.red;
//兄弟节点的左孩子存在，颜色设为黑色
if ((sl = xpl.left) != null)
sl.red = false;
}
//如果父节点存在，将父节点的颜色设为黑色
if (xp != null) {
xp.red = false;
//以父节点为支点进行右旋
root = rotateRight(root, xp);
}
// 替换节点指向根节点,平衡
x = root;
}
}
}
}
}
小结：
1.红黑树添加节点默认是红色的。
2.添加节点是根节点，直接变为黑色。
3.非根节点：
…3.1父节点为黑色，不需要调整
…3.2父节点为红色：
……3.2.1叔叔节点为红色：
…………1.将父节点设为黑色，将叔叔节点设为黑色。
…………2.将祖父节点设为红色。
…………3.如果祖父节点为根节点，将根节点再次设为黑色
……3.2.2叔叔节点为黑色:
…………1.将父节点设为黑色
…………2.将祖父节点设为红色
…………3.以祖父节点为支点进行旋转
4.左旋右旋：模拟一根绳子，吊两个珠子，有重力加持进行旋转。
八. 1.8hashmap总结:
1.数组+链表+红黑树。元素以键值对方式存在，键不能重复。键和值都可以为null。无序的，线程不安全的。
2.table容量默认为16，第一次put操作才会初始化，每次扩容2倍。最大是int值，2的32次方，超过最大值容量取int值。传入的容量小于0会抛异常。如果传入容量不是2的幂次方，会变成最接近的2的幂次方。2幂次方，为寻址做准备。
3.默认负载因子是0.75，容量达到0.75会扩容。
4.树化:链表转红黑树的阈值是8。转红黑树时，table最小为64。也就是说，链表达到8，每次链表长度+1，table都会扩容。直到链表长度>=8,且table>=64时，链表才会转红黑树。
5.树退化:resize()扩容时，在split()方法中会将红黑树拆分为lo和hi两棵树，每棵树节点<6会退化成链表。如果根节点root为null，或者root的左子树或右子树为null，也会退化。阈值为6是因为，转红黑树的阈值为8，既然是树退化，table必定>=64,那么退化的阈值为6可以防止反复切换树化和退化。
6.元素的位置是通过hash优化，高16位和低16位做异或运算（增强散列性），然后(table长度-1）&hash得到索引位置。
7.hash冲突：采用链表头插+红黑树解决。链表查找复杂度O(N)，红黑树O(logN)。为什么一开始不用红黑树呢。因为hash冲突的概率是很低的，且红黑树的节点比较占空间。转红黑树是比较耗时间且难以维护的。
8.数组table索引位置是链表的头结点，不一定是红黑树的头结点。因为removeTreeNode的最后一段代码，movable为true才会维持红黑树根节点在table索引处。
9.HashMap 则是使用安全失败机制 (fail-fast), 这种机制是指在用迭代器遍历一个集合对象的时候, 如果遍历过程中对集合对象的内容进行了修改, 则会抛出 Concurrent Modification Exception. 使用实际修改值modCount和预期修改值preCount做比较。
244
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
