数据结构与集合（三）

在计算机科学领域，哈希表是非常重要的数据结构，它们在数据组织和存储中扮演着重要角色。本文将介绍哈希表的的基本概念、特点以及实际应用，帮助读者更好地理解这种数据结构在算法设计和编程中的重要性。让我们一起深入探讨哈希表，揭示它们背后的奥秘和实用之处。

8、Map接口分析

8.1 哈希表的物理结构

8.2 HashMap中数据添加过程

8.2.1 JDK7中过程分析

8.2.2 JDK8中过程分析

8.3 Hashmap源码剖析

8.3.1 JDK1.7.0_07中源码

1、Entry

2、属性

3、构造器

4、put()方法

8.3.2 JDK1.8.0_127中源码

1、Node

2、属性

3、构造器

4、put()方法

8.4 LinkedHashMap源码剖析

9、Set接口分析

9.1 Set集合与Map集合的关系

9.2 源码剖析

10、【拓展】HashMap的相关问题

10.1 对哈希算法的理解

10.2 Entry中的hash属性为什么不直接使用key的hashCode()返回值呢？

10.3 HashMap是如何决定某个key-value存在哪个桶

10.4 为什么要保持table数组一直是2的n次幂

10.5 为什么JDK1.8会出现红黑树和链表共存

10.6 加载因子的值大小有什么关系

10.7 什么时候树化？什么时候反树化？

10.8 key-value中的key是否可以修改

8、Map接口分析

8.1 哈希表的物理结构

HashMap和Hashtable底层都是哈希表（也称散列表），其中维护了一个长度为2的幂次方的Entry类型的数组table，数组的每一个索引位置被称为一个桶(bucket)，你添加的映射关系(key,value)最终都被封装为一个Map.Entry类型的对象，放到某个table[index]桶中。

使用数组的目的是查询和添加的效率高，可以根据索引直接定位到某个table[index]。

8.2 HashMap中数据添加过程

8.2.1 JDK7中过程分析

// 在底层创建了长度为16的Entry[] table的数组
HashMap map = new HashMap();

map.put(key1,value1);
/*
分析过程如下：将(key1,value1)添加到当前hashmap的对象中。首先会调用key1所在类的hashCode()方法，计算key1的哈希值1，
此哈希值1再经过某种运算(hash())，得到哈希值2。此哈希值2再经过某种运算(indexFor())，确定在底层table数组中的索引位置i。（1）如果数组索引为i上的数据为空，则(key1,value1)直接添加成功   ------位置1（2）如果数组索引为i上的数据不为空，有(key2,value2)，则需要进一步判断：判断key1的哈希值2与key2的哈希值是否相同：（3） 如果哈希值不同，则(key1,value1)直接添加成功   ------位置2如果哈希值相同，则需要继续调用key1所在类的equals()方法，将key2放入equals()形参进行判断（4） equals方法返回false : 则(key1,value1)直接添加成功   ------位置3equals方法返回true : 默认情况下，value1会覆盖value2。位置1：直接将(key1,value1)以Entry对象的方式存放到table数组索引i的位置。
位置2、位置3：(key1,value1) 与现有的元素以链表的方式存储在table数组索引i的位置，新添加的元素指向旧添加的元素。...
在不断的添加的情况下，满足如下条件的情况下，会进行扩容:
if ((size >= threshold) && (null != table[bucketIndex])) :
默认情况下，当要添加的元素个数超过12(即：数组的长度 * loadFactor得到的结果)时，就要考虑扩容。补充：jdk7源码中定义的：
static class Entry<K,V> implements Map.Entry<K,V>
*/

map.get(key1);
/*
① 计算key1的hash值，用这个方法hash(key1)② 找index = table.length-1 & hash;③ 如果table[index]不为空，那么就挨个比较哪个Entry的key与它相同，就返回它的value
*/

map.remove(key1);
/*
① 计算key1的hash值，用这个方法hash(key1)② 找index = table.length-1 & hash;③ 如果table[index]不为空，那么就挨个比较哪个Entry的key与它相同，就删除它，把它前面的Entry的next的值修改为被删除Entry的next
*/

8.2.2 JDK8中过程分析

下面说明是JDK8相较于JDK7的不同之处：

① 使用HashMap()的构造器创建对象时，并没有在底层初始化长度为16的table数组。

② jdk8中添加的key,value封装到了HashMap.Node类的对象中。而非jdk7中的HashMap.Entry。

③ jdk8中新增的元素所在的索引位置如果有其他元素。在经过一系列判断后，如果能添加，则是旧的元素指向新的元素。而非jdk7中的新的元素指向旧的元素。“七上八下”

④ jdk7时底层的数据结构是：数组+单向链表。而jdk8时，底层的数据结构是：数组+单向链表+红黑树。
红黑树出现的时机：当某个索引位置i上的链表的长度达到8，且数组的长度超过64时，此索引位置上的元素要从单向链表改为红黑树。
如果索引i位置是红黑树的结构，当不断删除元素的情况下，当前索引i位置上的元素的个数低于6时，要从红黑树改为单向链表。

8.3 Hashmap源码剖析

8.3.1 JDK1.7.0_07中源码

1、Entry

key-value被封装为HashMap.Entry类型，而这个类型实现了Map.Entry接口。

public class HashMap<K,V>{transient Entry<K,V>[] table;static class Entry<K,V> implements Map.Entry<K,V> {final K key;V value;Entry<K,V> next;int hash;/*** Creates new entry.*/Entry(int h, K k, V v, Entry<K,V> n) {value = v;next = n;key = k;hash = h;}//略}
}

2、属性

//table数组的默认初始化长度
static final int DEFAULT_INITIAL_CAPACITY = 16;
//哈希表
transient Entry<K,V>[] table;
//哈希表中key-value的个数
transient int size;
//临界值、阈值（扩容的临界值）
int threshold;
//加载因子
final float loadFactor;
//默认加载因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;

3、构造器

public HashMap() {//DEFAULT_INITIAL_CAPACITY：默认初始容量16//DEFAULT_LOAD_FACTOR：默认加载因子0.75this(DEFAULT_INITIAL_CAPACITY, DEFAULT_LOAD_FACTOR);
}

public HashMap(int initialCapacity, float loadFactor) {//校验initialCapacity合法性if (initialCapacity < 0)throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity);//校验initialCapacity合法性 if (initialCapacity > MAXIMUM_CAPACITY)initialCapacity = MAXIMUM_CAPACITY;//校验loadFactor合法性if (loadFactor <= 0 || Float.isNaN(loadFactor))throw new IllegalArgumentException("Illegal load factor: " + loadFactor);//计算得到table数组的长度（保证capacity是2的整次幂）int capacity = 1;while (capacity < initialCapacity)capacity <<= 1;//加载因子，初始化为0.75this.loadFactor = loadFactor;// threshold 初始为默认容量threshold = (int)Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);//初始化table数组table = new Entry[capacity];useAltHashing = sun.misc.VM.isBooted() &&(capacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);init();
}

4、put()方法

public V put(K key, V value) {//如果key是null，单独处理，存储到table[0]中，如果有另一个key为null，value覆盖if (key == null)return putForNullKey(value);//对key的hashCode进行干扰，算出一个hash值/*hashCode值        xxxxxxxxxxtable.length-1    000001111hashCode值 xxxxxxxxxx  无符号右移几位和原来的hashCode值做^运算，使得hashCode高位二进制值参与计算，也发挥作用，降低index冲突的概率。*/int hash = hash(key);//计算新的映射关系应该存到table[i]位置，//i = hash & table.length-1，可以保证i在[0,table.length-1]范围内int i = indexFor(hash, table.length);//检查table[i]下面有没有key与我新的映射关系的key重复，如果重复替换valuefor (Entry<K,V> e = table[i]; e != null; e = e.next) {Object k;if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {V oldValue = e.value;e.value = value;e.recordAccess(this);return oldValue;}}modCount++;//添加新的映射关系addEntry(hash, key, value, i);return null;
}

其中

//如果key是null，直接存入[0]的位置
private V putForNullKey(V value) {//判断是否有重复的key，如果有重复的，就替换valuefor (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++;//把新的映射关系存入[0]的位置，而且key的hash值用0表示addEntry(0, null, value, 0);return null;
}

final int hash(Object k) {int h = 0;if (useAltHashing) {if (k instanceof String) {return sun.misc.Hashing.stringHash32((String) k);}h = hashSeed;}h ^= k.hashCode();// This function ensures that hashCodes that differ only by// constant multiples at each bit position have a bounded// number of collisions (approximately 8 at default load factor).h ^= (h >>> 20) ^ (h >>> 12);return h ^ (h >>> 7) ^ (h >>> 4);
}

static int indexFor(int h, int length) {return h & (length-1);
}

void addEntry(int hash, K key, V value, int bucketIndex) {//判断是否需要库容//扩容：（1）size达到阈值（2）table[i]正好非空if ((size >= threshold) && (null != table[bucketIndex])) {//table扩容为原来的2倍，并且扩容后，会重新调整所有key-value的存储位置resize(2 * table.length); //新的key-value的hash和index也会重新计算hash = (null != key) ? hash(key) : 0;bucketIndex = indexFor(hash, table.length);}//存入table中createEntry(hash, key, value, bucketIndex);
}

void createEntry(int hash, K key, V value, int bucketIndex) {Entry<K,V> e = table[bucketIndex];//原来table[i]下面的映射关系作为新的映射关系nexttable[bucketIndex] = new Entry<>(hash, key, value, e);//个数增加size++; 
}

8.3.2 JDK1.8.0_127中源码

1、Node

key-value被封装为HashMap.Node类型或HashMap.TreeNode类型，它俩都直接或间接的实现了Map.Entry接口。

存储到table数组的可能是Node结点对象，也可能是TreeNode结点对象，它们也是Map.Entry接口的实现类。即table[index]下的映射关系可能串起来一个链表或一棵红黑树。

public class HashMap<K,V>{transient Node<K,V>[] table;//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;}// 其它结构：略}//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);}}//....
}

2、属性

static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // 默认的初始容量 16
static final int MAXIMUM_CAPACITY = 1 << 30; //最大容量  1 << 30
static final float DEFAULT_LOAD_FACTOR = 0.75f;  //默认加载因子
static final int TREEIFY_THRESHOLD = 8; //默认树化阈值8，当链表的长度达到这个值后，要考虑树化
static final int UNTREEIFY_THRESHOLD = 6;//默认反树化阈值6，当树中结点的个数达到此阈值后，要考虑变为链表//当单个的链表的结点个数达到8，并且table的长度达到64，才会树化。
//当单个的链表的结点个数达到8，但是table的长度未达到64，会先扩容
static final int MIN_TREEIFY_CAPACITY = 64; //最小树化容量64transient Node<K,V>[] table; //数组
transient int size;  //记录有效映射关系的对数，也是Entry对象的个数
int threshold; //阈值，当size达到阈值时，考虑扩容
final float loadFactor; //加载因子，影响扩容的频率

3、构造器

public HashMap() {this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted (其他字段都是默认值)
}

4、put()方法

public V put(K key, V value) {return putVal(hash(key), key, value, false, true);
}

其中

static final int hash(Object key) {int h;//如果key是null，hash是0//如果key非null，用key的hashCode值 与 key的hashCode值高16进行异或//		即就是用key的hashCode值高16位与低16位进行了异或的干扰运算/*index = hash & table.length-1如果用key的原始的hashCode值  与 table.length-1 进行按位与，那么基本上高16没机会用上。这样就会增加冲突的概率，为了降低冲突的概率，把高16位加入到hash信息中。*/return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}

final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) {Node<K,V>[] tab; //数组Node<K,V> p;  //一个结点int n, i; //n是数组的长度   i是下标//tab和table等价//如果table是空的if ((tab = table) == null || (n = tab.length) == 0){n = (tab = resize()).length;/*tab = resize();n = tab.length;*//*如果table是空的，resize()完成了①创建了一个长度为16的数组②threshold = 12n = 16*/}//i = (n - 1) & hash ，下标 = 数组长度-1 & hash//p = tab[i] 第1个结点//if(p==null) 条件满足的话说明 table[i]还没有元素if ((p = tab[i = (n - 1) & hash]) == null){//把新的映射关系直接放入table[i]tab[i] = newNode(hash, key, value, null);//newNode（）方法就创建了一个Node类型的新结点，新结点的next是null}else {Node<K,V> e; K k;//p是table[i]中第一个结点//if(table[i]的第一个结点与新的映射关系的key重复)if (p.hash == hash &&((k = p.key) == key || (key != null && key.equals(k))))e = p;//用e记录这个table[i]的第一个结点else if (p instanceof TreeNode){ //如果table[i]第一个结点是一个树结点//单独处理树结点//如果树结点中，有key重复的，就返回那个重复的结点用e接收，即e!=null//如果树结点中，没有key重复的，就把新结点放到树中，并且返回null，即e=nulle = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);}else {//table[i]的第一个结点不是树结点，也与新的映射关系的key不重复//binCount记录了table[i]下面的结点的个数for (int binCount = 0; ; ++binCount) {//如果p的下一个结点是空的，说明当前的p是最后一个结点if ((e = p.next) == null) {//把新的结点连接到table[i]的最后p.next = newNode(hash, key, value, null);//如果binCount>=8-1，达到7个时if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st//要么扩容，要么树化treeifyBin(tab, hash);break;}//如果key重复了，就跳出for循环，此时e结点记录的就是那个key重复的结点if (e.hash == hash &&((k = e.key) == key || (key != null && key.equals(k))))break;p = e;//下一次循环，e=p.next，就类似于e=e.next，往链表下移动}}//如果这个e不是null，说明有key重复，就考虑替换原来的valueif (e != null) { // existing mapping for keyV oldValue = e.value;if (!onlyIfAbsent || oldValue == null)e.value = value;afterNodeAccess(e); //什么也没干return oldValue;}}++modCount;//元素个数增加//size达到阈值if (++size > threshold)resize(); //一旦扩容，重新调整所有映射关系的位置afterNodeInsertion(evict); //什么也没干return null;
}

final Node<K,V>[] resize() {Node<K,V>[] oldTab = table; //oldTab原来的table//oldCap：原来数组的长度int oldCap = (oldTab == null) ? 0 : oldTab.length;//oldThr：原来的阈值int oldThr = threshold;//最开始threshold是0//newCap，新容量//newThr：新阈值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)//newCap = 旧的容量*2 ，新容量<最大数组容量限制//新容量：32,64，...//oldCap >= 初始容量16//新阈值重新算 = 24，48 ....newThr = oldThr << 1; // double threshold}else if (oldThr > 0) // initial capacity was placed in thresholdnewCap = oldThr;else {               // zero initial threshold signifies using defaultsnewCap = DEFAULT_INITIAL_CAPACITY; //新容量是默认初始化容量16//新阈值= 默认的加载因子 * 默认的初始化容量 = 0.75*16 = 12newThr = (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; //阈值赋值为新阈值12，24.。。。//创建了一个新数组，长度为newCap，16，32,64.。。@SuppressWarnings({"rawtypes","unchecked"})Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];table = newTab;if (oldTab != null) { //原来不是空数组//把原来的table中映射关系，倒腾到新的table中for (int j = 0; j < oldCap; ++j) {Node<K,V> e;if ((e = oldTab[j]) != null) {//e是table下面的结点oldTab[j] = null; //把旧的table[j]位置清空if (e.next == null) //如果是最后一个结点newTab[e.hash & (newCap - 1)] = e; //重新计算e的在新table中的存储位置，然后放入else if (e instanceof TreeNode) //如果e是树结点//把原来的树拆解，放到新的table((TreeNode<K,V>)e).split(this, newTab, j, oldCap);else { // preserve orderNode<K,V> loHead = null, loTail = null;Node<K,V> hiHead = null, hiTail = null;Node<K,V> next;//把原来table[i]下面的整个链表，重新挪到了新的table中do {next = e.next;if ((e.hash & oldCap) == 0) {if (loTail == null)loHead = e;elseloTail.next = e;loTail = e;}else {if (hiTail == null)hiHead = e;elsehiTail.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;
}

Node<K,V> newNode(int hash, K key, V value, Node<K,V> next) {//创建一个新结点return new Node<>(hash, key, value, next);
}

final void treeifyBin(Node<K,V>[] tab, int hash) {int n, index; Node<K,V> e;//MIN_TREEIFY_CAPACITY：最小树化容量64//如果table是空的，或者  table的长度没有达到64if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)resize();//先扩容else if ((e = tab[index = (n - 1) & hash]) != null) {//用e记录table[index]的结点的地址TreeNode<K,V> hd = null, tl = null;/*do...while，把table[index]链表的Node结点变为TreeNode类型的结点*/do {TreeNode<K,V> p = replacementTreeNode(e, null);if (tl == null)hd = p;//hd记录根结点else {p.prev = tl;tl.next = p;}tl = p;} while ((e = e.next) != null);//如果table[index]下面不是空if ((tab[index] = hd) != null)hd.treeify(tab);//将table[index]下面的链表进行树化}
}

8.4 LinkedHashMap源码剖析

内部定义的Entry如下：

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);}
}

LinkedHashMap重写了HashMap中的newNode()方法：

Node<K,V> newNode(int hash, K key, V value, Node<K,V> e) {LinkedHashMap.Entry<K,V> p =new LinkedHashMap.Entry<K,V>(hash, key, value, e);linkNodeLast(p);return p;
}

TreeNode<K,V> newTreeNode(int hash, K key, V value, Node<K,V> next) {TreeNode<K,V> p = new TreeNode<K,V>(hash, key, value, next);linkNodeLast(p);return p;
}

9、Set接口分析

9.1 Set集合与Map集合的关系

Set的内部实现其实是一个Map，Set中的元素，存储在HashMap的key中。即HashSet的内部实现是一个HashMap，TreeSet的内部实现是一个TreeMap，LinkedHashSet的内部实现是一个LinkedHashMap。

9.2 源码剖析

HashSet源码：

//构造器
public HashSet() {map = new HashMap<>();
}public HashSet(int initialCapacity, float loadFactor) {map = new HashMap<>(initialCapacity, loadFactor);
}public HashSet(int initialCapacity) {map = new HashMap<>(initialCapacity);
}//这个构造器是给子类LinkedHashSet调用的
HashSet(int initialCapacity, float loadFactor, boolean dummy) {map = new LinkedHashMap<>(initialCapacity, loadFactor);
}//add()方法：
public boolean add(E e) {return map.put(e, PRESENT)==null;
}
//其中，
private transient HashMap<E,Object> map;
private static final Object PRESENT = new Object();//iterator()方法：
public Iterator<E> iterator() {return map.keySet().iterator();
}

LinkedHashSet源码：

//构造器
public LinkedHashSet() {super(16, .75f, true);
} 
public LinkedHashSet(int initialCapacity) {super(initialCapacity, .75f, true);//调用HashSet的某个构造器
}
public LinkedHashSet(int initialCapacity, float loadFactor) {super(initialCapacity, loadFactor, true);//调用HashSet的某个构造器
}

TreeSet源码：

public TreeSet() {this(new TreeMap<E,Object>());
}TreeSet(NavigableMap<E,Object> m) {this.m = m;
}
//其中，
private transient NavigableMap<E,Object> m;//add()方法：
public boolean add(E e) {return m.put(e, PRESENT)==null;
}
//其中，
private static final Object PRESENT = new Object();

10、【拓展】HashMap的相关问题

10.1 对哈希算法的理解

hash算法是一种可以从任何数据中提取出其“指纹”的数据摘要算法，它将任意大小的数据映射到一个固定大小的序列上，这个序列被称为hash code、数据摘要或者指纹。比较出名的hash算法有MD5、SHA。hash是具有唯一性且不可逆的，唯一性是指相同的“对象”产生的hash code永远是一样的。

10.2 Entry中的hash属性为什么不直接使用key的hashCode()返回值呢？

不管是JDK1.7还是JDK1.8中，都不是直接用key的hashCode值直接与table.length-1计算求下标的，而是先对key的hashCode值进行了一个运算，JDK1.7和JDK1.8关于hash()的实现代码不一样，但是不管怎么样都是为了提高hash code值与 (table.length-1)的按位与完的结果，尽量的均匀分布。

虽然算法不同，但是思路都是将hashCode值的高位二进制与低位二进制值进行了异或，然高位二进制参与到index的计算中。

为什么要hashCode值的二进制的高位参与到index计算呢？

因为一个HashMap的table数组一般不会特别大，至少在不断扩容之前，那么table.length-1的大部分高位都是0，直接用hashCode和table.length-1进行&运算的话，就会导致总是只有最低的几位是有效的，那么就算你的hashCode()实现的再好也难以避免发生碰撞，这时让高位参与进来的意义就体现出来了。它对hashcode的低位添加了随机性并且混合了高位的部分特征，显著减少了碰撞冲突的发生。

10.3 HashMap是如何决定某个key-value存在哪个桶

因为hash值是一个整数，而数组的长度也是一个整数，有两种思路：

①hash 值 % table.length会得到一个[0,table.length-1]范围的值，正好是下标范围，但是用%运算效率没有位运算符&高。

②hash 值 & (table.length-1)，任何数 & (table.length-1)的结果也一定在[0, table.length-1]范围。

10.4 为什么要保持table数组一直是2的n次幂

因为如果数组的长度为2的n次幂，那么table.length-1的二进制就是一个高位全是0，低位全是1的数字，这样才能保证每一个下标位置都有机会被用到。

10.5 为什么JDK1.8会出现红黑树和链表共存

因为当冲突比较严重时，table[index]下面的链表就会很长，那么会导致查找效率大大降低，而如果此时选用二叉树可以大大提高查询效率。

但是二叉树的结构又过于复杂，占用内存也较多，如果结点个数比较少的时候，那么选择链表反而更简单。所以会出现红黑树和链表共存。

10.6 加载因子的值大小有什么关系

如果太大，threshold就会很大，那么如果冲突比较严重的话，就会导致table[index]下面的结点个数很多，影响效率。

如果太小，threshold就会很小，那么数组扩容的频率就会提高，数组的使用率也会降低，那么会造成空间的浪费。

10.7 什么时候树化？什么时候反树化？

static final int TREEIFY_THRESHOLD = 8;//树化阈值
static final int UNTREEIFY_THRESHOLD = 6;//反树化阈值
static final int MIN_TREEIFY_CAPACITY = 64;//最小树化容量

当某table[index]下的链表的结点个数达到8，并且table.length>=64，那么如果新Entry对象还添加到该table[index]中，那么就会将table[index]的链表进行树化。
当某table[index]下的红黑树结点个数少于6个，此时，
- 当继续删除table[index]下的树结点，最后这个根结点的左右结点有null，或根结点的左结点的左结点为null，会反树化
- 当重新添加新的映射关系到map中，导致了map重新扩容了，这个时候如果table[index]下面还是小于等于6的个数，那么会反树化