jdk8 HashMap 源码解析-红黑树
Posted MyClass社区
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了jdk8 HashMap 源码解析-红黑树相关的知识，希望对你有一定的参考价值。
HashMap是我们经常用到的java数据结构，很多人都知道它的底层数据结构是什么:数组+链表。这个回答放在jdk8其实是不对的，java8优化了大容量hashMap的底层数据结构，我们今天就来撸一遍的HashMap源码。
一.开头的注释
注释是阅读源码的第一手资料，自己翻译一遍，也没多少，翻译的过程中还可以学习英语，以后要是遇到国外的工程师，一些专用名词也能说两句，这里就不贴注解了，我进行简单的浓缩一下，可以发现最基本的HashMap特性面试都在这里。
第一段：
HashMap 实现map接口，实现map所有的操作，和HashTable相似，不保证顺序，允许空键值
第二段：
迭代器遍历时间和hashMap实例size（hash桶数量+Key-value数量）成正比，在设定初始容量时，应考虑Map中预期的条目数量及其载荷因子。如果迭代性能很重要，不要将初始容量设置得太高（或者负载因子太低）是非常重要的。
第三段
超过最大负载比例，就会刷新原来的hashMap结构，rehashed，所以hash扩容一般的需要两倍的hash桶才能满足扩容需求；
第四段：
默认的负载因子是时间和空间消耗的平衡点，factor：越高会减少空间开销，越小就会增加查找成本。如果初始容量大于最大入口数除以负载因子，则不会发生重新刷新操作。
第五段
1.太过的元素需要存储是，需要创建充足的容量避免经常rehash操作 2.使用具有相同哈希码的许多密钥是降低任何哈希表性能的一种可靠方法。 3.为了改善影响，当键继承Comparable时，这个类可以使用键之间的比较顺序来帮助打破关系。
第六段
1.多线程并发修改会出现线程不安全，会出现并发修改map结构 2.结构修改是添加或删除一个或多个映射的任何操作;只是改变与实例已经包含的关键字相关联的值不是结构修改。 3.需要一个同步对象进行保证同步，或者用Collections.synchronizedMap。
注意：主要是resize的过程中会动态的修改链表的位置，主要并发情况下node获取next的时候会出现死循环。
第七段
同步集合类:Collections.synchronizedMap 1.如果在迭代器创建后的任何时候结构上都修改了映射，除了通过迭代器自己的 remove 方法外， 迭代器将抛出一个ConcurrentModificationException 2.并发修改，迭代器通过快速失败来避免风险 3.迭代器的快速失败行为，应该只用于检测错误，不可能做出任何硬性保证。
二.几个重要的参数
/**
* 初始化容量大小，默认16
*/
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
/**
* 最大容量2的30次方
*/
static final int MAXIMUM_CAPACITY = 1 << 30;
/**
* 负载因子：0.75f,超过容量的比例，则扩容
*/
static final float DEFAULT_LOAD_FACTOR = 0.75f;
/**
* 链表size超过该阈值时，用树来代替链表，默认值是8
*/
static final int TREEIFY_THRESHOLD = 8;
/**
* 当执行resize操作时，当桶中bin的数量少于该值时使用链表来代替树。默认值是6
*/
static final int UNTREEIFY_THRESHOLD = 6;
/**
* hash容量小于MIN_TREEIFY_CAPACITY，都是通过resize来扩容，不会启动树结构装化，哪怕是链表size > 8
*/
static final int MIN_TREEIFY_CAPACITY = 64;
画个图理解
三.源码
1.Hash
定位桶的位置，这里不是单纯的hashcode，hashCode的高16位与hashCode进行异或运算，为了在table的length较小的时候，让高位也参与运算，并且不会有太大的开销。
static final int hash(Object key) {
int h;
// 1.先拿到key的hashCode值; 2.将hashCode的高16位参与运算
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
int n = tab.length;
// 将(tab.length - 1) 与 hash值进行&运算，得到（hash桶的位置）
int index = (n - 1) & hash;
2.put方法
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是否为空或者length等于0, 如果是则调用resize方法进行初始化
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
// 通过hash值计算索引位置, 如果table表该索引位置节点为空则新增一个
if ((p = tab[i = (n - 1) & hash]) == null)// 将索引位置的头节点赋值给p
tab[i] = newNode(hash, key, value, null);
else { // table表该索引位置不为空
Node<K,V> e; K k;
if (p.hash == hash && // 判断p节点的hash值和key值是否跟传入的hash值和key值相等
((k = p.key) == key || (key != null && key.equals(k))))
e = p; // 如果相等, 则p节点即为要查找的目标节点，赋值给e
// 判断p节点是否为TreeNode, 如果是则调用红黑树的putTreeVal方法查找目标节点
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else { // 走到这代表p节点为普通链表节点
for (int binCount = 0; ; ++binCount) { // 遍历此链表, binCount用于统计节点数
if ((e = p.next) == null) { // p.next为空代表不存在目标节点则新增一个节点插入链表尾部
p.next = newNode(hash, key, value, null);
// 计算节点是否超过8个, 减一是因为循环是从p节点的下一个节点开始的
if (binCount >= TREEIFY_THRESHOLD - 1)
treeifyBin(tab, hash);// 如果超过8个，调用treeifyBin方法将该链表转换为红黑树
break;
}
if (e.hash == hash && // e节点的hash值和key值都与传入的相等, 则e即为目标节点,跳出循环
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e; // 将p指向下一个节点
}
}
// e不为空则代表根据传入的hash值和key值查找到了节点,将该节点的value覆盖,返回oldValue
if (e != null) {
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e); // 用于LinkedHashMap
return oldValue;
}
}
++modCount;
if (++size > threshold) // 插入节点后超过阈值则进行扩容
resize();
afterNodeInsertion(evict); // 用于LinkedHashMap
return null;
}
1.如果通过hash值计算索引位置, 如果table表该索引位置节点为空则直接新增一个。
2.hash表有值，如果是树类型，则直接调用红黑数进行插入putTreeVal（）操作
3.如果是链表类型，则赋值node.next = new Node()
4.发现node节点数超过8,并且hash容量小于64,则转化为红黑树类型：调用treeifyBin，这里操作很多，包括node遍历转为TreeNode, 完事之后在遍历TreeNode，和根节点（初始为node的第一个值）比较hash大小，小就赋值左节点，大的赋值右接点，再平衡操作左旋和右旋来选出新root节点。
5.最后还会进行一次最终判断是否需要resize扩容。
三.红黑树构造
看之前，需要了解一下红黑树特征：
（1）每个节点或者是黑色，或者是红色。
（2）根节点是黑色。
（3）每个叶子节点（NIL）是黑色。 [注意：这里叶子节点，是指为空(NIL或NULL)的叶子节点！]
（4）如果一个节点是红色的，则它的子节点必须是黑色的。
（5）从一个节点到该节点的子孙节点的所有路径上包含相同数目的黑节点。
红黑树的构造大致分为四部：
1,根节点赋值;
2.遍历所有的根节点,比较hash大小，判断是向左查找还是向右查找;
3.平衡树操作，调整树的结构满足红黑树的特性
4.将根节点挂到table索引位置的头结点;
final void treeify(Node<K,V>[] tab) { // 构建红黑树
TreeNode<K,V> root = null;
for (TreeNode<K,V> x = this, next; x != null; x = next) {// this即为调用此方法的TreeNode
next = (TreeNode<K,V>)x.next; // next赋值为x的下个节点
x.left = x.right = null; // 将x的左右节点设置为空
//1.开始没有根结点, 则将x设置为根结点
if (root == null) {
x.parent = null; // 根结点没有父节点
x.red = false; // 根结点必须为黑色
root = x; // 将x设置为根结点
}
//2.遍历树，获取X节点安插的位置：如果当前节点x不是根结点, 则从根节点开始查找属于该节点的位置
else {
K k = x.key; // k赋值为x的key
int h = x.hash; // h赋值为x的hash值
Class<?> kc = null;
for (TreeNode<K,V> p = root;;) {
int dir, ph;
K pk = p.key;
if ((ph = p.hash) > h) // 如果x节点的hash值小于p节点的hash值
dir = -1; // 则将dir赋值为-1, 代表向p的左边查找
else if (ph < h) // 与上面相反, 如果x节点的hash值大于p节点的hash值
dir = 1; // 则将dir赋值为1, 代表向p的右边查找
// 走到这代表x的hash值和p的hash值相等，则比较key值
else if ((kc == null && // 如果k没有实现Comparable接口 或者 x节点的key和p节点的key相等
(kc = comparableClassFor(k)) == null) ||
(dir = compareComparables(kc, k, pk)) == 0)
// 使用定义的一套规则来比较x节点和p节点的大小，用来决定向左还是向右查找
dir = tieBreakOrder(k, pk);
TreeNode<K,V> xp = p; // xp赋值为x的父节点,中间变量用于下面给x的父节点赋值
// dir<=0则向p左边查找,否则向p右边查找,如果为null,则代表该位置即为x的目标位置
if ((p = (dir <= 0) ? p.left : p.right) == null) {
x.parent = xp; // x的父节点即为最后一次遍历的p节点
if (dir <= 0) // 如果时dir <= 0, 则代表x节点为父节点的左节点
xp.left = x;
else // 如果时dir > 0, 则代表x节点为父节点的右节点
xp.right = x;
//3.平衡操作：进行红黑树的插入平衡(通过左旋、右旋和改变节点颜色来保证当前树符合红黑树的要求)
root = balanceInsertion(root, x);
break;
}
}
}
}
//4.如果root节点不在table索引位置的头结点, 则将其调整为头结点
moveRootToFront(tab, root);
}
四.后续
红黑树的平衡很复杂，将红黑树节点类copy出来，进行一次Debug，一般的很难debug进去，可以看一下平衡的逻辑，有兴趣可以了解一下;新建一个Node[1]，代表一个hash桶，里边元素有一个链表Node,nodehash值都是1,然后将链表进行红黑树转化，就可以看到红黑树的平衡操作，可以看到这8个元素最后是怎么选出5为根节点的。
public static void main(String[] args) {
Node<String,String>[] newNodeArray = (Node<String,String>[])new Node[1];
Node<String,String> e = null;
Node<String,String> temp = null;
for (int i = 1; i <= 8 ; i++) {
if(i==0){
e = new Node(1,"key"+String.valueOf(i),"value"+String.valueOf(i),null);
}else {
e = new Node(1,"key"+String.valueOf(i),"value"+String.valueOf(i),e);
}
}
newNodeArray[0] = e;
TreeNode<String,String> hd = null, tl = null;
int index = 0;
do {
TreeNode<String,String> p = new TreeNode<>(e.hash, e.key, e.value, null);
if (tl == null)
hd = p;
else {
p.prev = tl;
tl.next = p;
}
tl = p;
} while ((e = e.next) != null);
//hd：遍历完的Node，重做的TreeNode的根节点
if ((newNodeArray[index] = hd) != null)
hd.treeify(newNodeArray);
}
以上是关于jdk8 HashMap 源码解析-红黑树的主要内容，如果未能解决你的问题，请参考以下文章
jdk1.8的hashmap真的是大于8就转换成红黑树，小于6就变成链表吗