HashMap
继承关系
public class HashMap extends AbstractMap
implements Map, Cloneable, Serializable 实现接口
Serializable, Cloneable, Map
基本属性
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; //默认初始化大小 16
static final float DEFAULT_LOAD_FACTOR = 0.75f; //负载因子0.75
static final Entry[] EMPTY_TABLE = {}; //初始化的默认数组
transient int size; //HashMap中元素的数量
int threshold; //判断是否需要调整HashMap的容量构造函数
HashMap() //无参构造方法
HashMap(int initialCapacity) //指定初始容量的构造方法
HashMap(int initialCapacity, float loadFactor) //指定初始容量和负载因子
HashMap(Map m) //指定集合，转化为HashMapHashMap提供了四个构造方法，构造方法中 ，依靠第三个方法来执行的，但是前三个方法都没有进行数组的初始化操作，即使调用了构造方法，此时存放HaspMap中数组元素的table表长度依旧为0 。在第四个构造方法中调用了inflateTable()方法完成了table的初始化操作，并将m中的元素添加到HashMap中。
哈希表来存储
hashmap用hash表来存储
hash表，也叫散列表，根据关键代码key value 直接访问的数据结构
哈希表是数组的一种拓展，没有哈希表就没有散列表
什么是哈希函数？
我们使用一个下标范围比较大的数组来存储元素。可以设计一个函数（哈希函数， 也叫做散列函数），使得每个元素的关键字都与一个函数值（即数组下标）相对应，于是用这个数组单元来存储这个元素；也可以简单的理解为，按照关键字为每一个元素"分类"，然后将这个元素存储在相应"类"所对应的地方。
但是，不能够保证每个元素的关键字与函数值是一一对应的，因此极有可能出现对于不同的元素，却计算出了相同的函数值，这样就产生了"冲突"
那么hashmap核心问题是什么？
构建一个哈希函数可以使key均匀的分布
冲突，会使不同的对象存到一个位置上
java为了解决这个冲突 hashmap采取了链寻址法，链地址法其实就是数组 + 链表
为什么使用数组 + 链表，大于8个为什么使用红黑树？
我们知道hashmap是要查询的，查询的话链表查询速度就会变慢，所以使用红黑树来进行查询
那为什么不能使用正常的二叉搜索树，因为极端情况下会变成一个链表，效率很低
那为什么不能使用完美的二叉平衡树，因为完美二叉平衡树旋转次数会很多，也是一种耗时
红黑树会在下面详细介绍
Hashmap如何实现这个链表的？或者说，它是如何实现红黑树 + 链表的模式的
static class Node implements Map.Entry {
final int hash;
final K key;
V value;
这个地方
Node next;
Node(int hash, K key, V value, Node 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;
}
} 这个next不陌生吧，链表就是靠这个模式实现的，接下来看下put方法
(h = key.hashCode()) ^ (h >>> 16) 然后 tab[i = (n - 1) & hash]) 确定位置
这样搞高位的 16位也参与进来，这样减小了碰撞的可能性
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
static final int hash(Object key) {
int h;
计算位置，也就是所谓的key
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node[] tab; Node p; int n, i;
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
如果走到这个else证明发生了冲突，需要进入链表或者红黑树
else {
Node e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
如果是红黑树
else if (p instanceof TreeNode)
e = ((TreeNode)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);
如果大于8个就要考虑用链表还是红黑树
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
大于最大容量就扩容
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
} hashmap的红黑树
这里详细讲讲红黑树
每个节点要么是黑色，要么是红色
根节点是黑色，叶子节点是黑色
每个红色节点下面的两个节点是黑色
每个节点到叶子节点的路径都包含数量相同的黑色节点
画个图看看
红黑树是一个二叉查找树，左节点小于父节点，右节点大于父节点
我们一步1图演示
先添加1个1 再添加一个5 这里其实是有一个疑问的，为什么新添加是红色节点？按照规则，叶子节点根节点都应该是黑色啊？
其实是这样的
其实我们画出来的这些才是规定里的叶子节点，现在已有的这些节点并不是叶子节点 叶子节点是不存在的，虚拟出来的，只要没有满树就是有叶子节点
当你添加一个新节点到红黑树时，该节点通常是红色的。尽管你添加的节点是红色的，但是在插入后的修复过程中，系统会确保树的平衡性和其他性质得到维持。 OK那不纠结，继续看
那么再添加一个9 按照刚才说的，新添加的是红色的，我们不纠结，大于父节点的在右，小于父节点的在左，但是5和9都大于1，这个时候就要发生旋转为什么？
红黑树是一个二叉查找树，左节点小于父节点，右节点大于父节点
那么我们再添加一个44,44也是红的，是不是不对劲，红色黑色必须间隔开嘛，那么这时候按照之前说的，新添加是一个红色节点，那么1和9就应该变成黑色节点
然后再添加55，按照刚才规则，55也是红色节点
OK，这就没问题了，那假如我再新增节点是否应该在左节点？
按照之前说的，新增是红的，那么55和09变成黑节点，没问题，那为什么77不放在左节点？
这还是之前的规则
红黑树是一个二叉查找树，左节点小于父节点，右节点大于父节点
接下来99，99和77都大于55，那就应该左旋
OK，到这没问题
接下来，我们加一个120，那会变成什么样？
新增就是红色，红色应该挂在99下面对吧
好，120是红节点，那99就应该是黑节点
根据 每个红色节点下面的两个节点是黑色
那么 99和 55都变成黑色
77现在变成了红节点，那么44就应该变成黑节点
44变成了黑节点，那么就不在符合红黑树两边长度
那么这个时候就要发生旋转那旋转谁？旋转44
那为什么不旋转77旋转44？
红黑树旋转只考虑CPUG，什么是CPUG？这个问题我们一会下边会有总结 可以先记着这个问题，先看下面
有一个原则就是父母围着子女转，并且基于最短路径
44应该变色嘛？应该，因为77变色后44不符合规则，变色我们就视他为新节点，那么44变色又不符合规则，那么这个时候在跟节点就需要旋转，按照最短路径需要左旋，所以结果如下
好，上面是基本规则，我们来看实现
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
省略之前的一车无用代码
else if (p instanceof TreeNode)
e = ((TreeNode)p).putTreeVal(this, tab, hash, key, value); 先看数据结构
static final class TreeNode extends LinkedHashMap.LinkedHashMapEntry {
TreeNode parent; // red-black tree links
TreeNode left;
TreeNode right;
TreeNode prev; // needed to unlink next upon deletion
boolean red; 父节点 左节点 右节点 是否为红色
接下来看put方法，是怎么实现的
final TreeNode putTreeVal(HashMap map, Node[] tab,
int h, K k, V v) {
Class kc = null;
boolean searched = false;
拿到跟节点
TreeNode root = (parent != null) ? root() : this;
for (TreeNode p = root;;) {
int dir, ph; K pk;
比根节点小，向左
if ((ph = p.hash) > h)
dir = -1;
比根节点大，向右
else if (ph < h)
dir = 1;
如果key一样直接返回
else if ((pk = p.key) == k || (k != null && k.equals(pk)))
return p;
hash值一样但是k不一样
else if ((kc == null &&
(kc = comparableClassFor(k)) == null) ||
(dir = compareComparables(kc, k, pk)) == 0) {
searched代表是否左右子树检查过
if (!searched) {
TreeNode 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);
}
TreeNode xp = p;
if证明了是叶子节点
if ((p = (dir <= 0) ? p.left : p.right) == null) {
既要进链表也要进红黑树，这个有可能来回变化
Node xpn = xp.next;
TreeNode 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)xpn).prev = x;
自适应调整
moveRootToFront(tab, balanceInsertion(root, x));
return null;
}
}
} 下面就是自平衡流程
接下来说说，红黑树添加的几种可能，也就是所谓自平衡
那么一共有几种可能？
c=root
c.parent = back
c.parent = red && c.uncle == red
c.parent = red && (c.uncle = balck || c.uncle == nil)
依旧是 一步一图
c=root 就是新增就是根节点
如果是黑颜色的 c.parent = back
如果是红颜色？但是没有叔叔节点或者叔叔节点为黑色 c.parent = red && c.uncle == red
那这个时候 就要变色 9变成黑色 但是根据两边黑色数量是要相等的，这就要旋转
那么如果叔叔节点是红色呢？
我们举两个例子
1
2
其实就是会发生变色，看下结果
当红黑树 如果是红颜色？但是没有叔叔节点或叔叔节点为黑色 c.parent = red && c.uncle == red
就会发生旋转 + 变色，如果有叔叔节点，且为红色，那就只发生变色，如果为根节点，那就会把根节点变成黑色
OK，那继续看hashmap源码
static TreeNode balanceInsertion(TreeNode root,
TreeNode x) {
新进入的节点都是红色的
x.red = true;
for (TreeNode xp, xpp, xppl, xppr;;) {
如果它就是根节点，把根节点置黑，并且返回 循环到根节点就可以结束可
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)) {
如果叔叔节点不为空 且叔叔节点，为红色，那么按照之前说的，光变色不旋转
if ((xppr = xpp.right) != null && xppr.red) {
右边变黑
xppr.red = false;
父亲变黑
xp.red = false;
爷爷也变黑
xpp.red = true;
有意思的来了，x这个时候变成了自己的爷爷节点，这是个循环，会检查自己的爷爷节点，它被视作新节点继续向上
x = xpp;
}
else {
另一个分支就是，如果叔叔节点为空或者为黑色，那就是这个分支，是要旋转的
if (x == xp.right) {
如果是右节点，那就要向左转，为什么？
根据父节点围着子节点转，那么最短的就是左转，转谁？转自己的父节点
root = rotateLeft(root, x = xp);
xpp = (xp = x.parent) == null ? null : xp.parent;
}
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);
}
}
}
}
}
} 有没有点晕？
总结下，我们每次只看四个节点，调完四个再继续向上看，如果超过四个你就会晕，调完四个，再调四个，先调整完4个，我们用哪个节点向上看？是爷爷节点，我们再看一次这个流程
如果是1个，直接跳出循环
那如果父亲是黑色节点？跳出循环
那么复杂一点的情况呢？
那么就变成了4个一组依次向上检查
我们先检查4个，哪四个？
那么有叔叔节点，且为红色，那么只变色，不旋转
OK，这个时候我们拿祖父节点继续向上就可以了
那如果此时我再加一个节点，符合了叔叔节点为空，那就应该旋转，具体左旋右旋，就要看哪个旋转角度小
那么这种情况下，符合旋转嘛？符合啊
结果就是这个了，那再复杂点，我们来看
还是最初的案例
叔节点为红色，那，只变色，不旋转
我们拿着爷爷节点为起点，再看这个图
叔叔节点为黑色，父节点为红色，是不是要旋转啦？
当前是一个右节点，那么应该左旋
结论不就有了
hashmap的扩容
final Node[] resize() {
// 成员变量的table赋值给oldTab，就是将扩容前的table赋值给oldTab
Node[] oldTab = table;
// 记录Map当前的容量
// 如果当前数组等于null长度返回0，否则返回当前数组的长度
int oldCap = (oldTab == null) ? 0 : oldTab.length;
//当前数组阈值
int oldThr = threshold;
// 声明两个变量，用来记录新的容量和阈值
int newCap, newThr = 0;
// 若当前容量不为0，表示存储数据的数组已经被初始化过
if (oldCap > 0) {
// 判断当前容量是否超过了允许的最大容量
if (oldCap >= MAXIMUM_CAPACITY) {
// 若超过最大容量，表示无法再进行扩容
// 则更新当前的阈值为int的最大值，并返回旧数组
threshold = Integer.MAX_VALUE;
return oldTab;
}
// 将旧容量*2得到新容量，若新容量未超过最大容量值，并且旧容量大于默认初始容量（16），才则将旧阈值*2得到新阈值
// 在以前的扩容阀值的基础上翻倍，假如以前的数组长度16 扩容阀值为 16*0.75=12
// 扩容新的容量为之前的容量的2倍newCap = oldCap << 1 左移一位 原来的大小为 16 扩容以后位32 以此类推
// 新的扩容阀值也为原来的2倍 newThr = oldThr << 1; 左移动1位 原来的扩容阀值为12 现在的阀值为24 以此类推
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
//将数组长度左移一位(翻倍) 新数组阈值变为之前的一倍
newThr = oldThr << 1; // double threshold
}
// 若不满足上面的oldCap > 0，表示数组还未初始化，
// 若当前阈值不为0，就将数组的新容量记录为当前的阈值；
// 为什么这里的oldThr在未初始化数组的时候就有值呢？
// 这是因为HashMap有两个带参构造器，可以指定初始容量，
// 若你调用了这两个可以指定初始容量的构造器，
// 这两个构造器就会将阈值记录为第一个大于等于你指定容量，且满足2^n的数（可以看看这两个构造器）
else if (oldThr > 0) // initial capacity was placed in threshold
//将老数组的阈值赋值给新数组
newCap = oldThr;
// 若上面的条件都不满足，表示你是调用默认构造器创建的HashMap，且还没有初始化table数组
else { // zero initial threshold signifies using defaults
// 则将新容量更新为默认初始容量（16）
// 阈值即为（容量*负载因子）12
// 初始化容量会走这个
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
// 经过上面的步骤后，newCap一定有值，但是若运行的是上面的第二个分支时，newThr还是0
// 所以若当前newThr还是0，则计算出它的值（容量*负载因子）
if (newThr == 0) {
// 再次扩容的阀值
float ft = (float)newCap * loadFactor;
// 获取新的阀值，小于最大容量就为上面计算的扩容阀值，否则为Integer.MAX_VALUE
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
// 将计算出的新阈值更新到成员变量threshold上
// 第一次添加的时候初始化threshold = newThr = 12
threshold = newThr;
@SuppressWarnings({"rawtypes","unchecked"})
// 创建一个记录新数组用来存HashMap中的元素，容量为新的容量newCap
// 若数组不是第一次初始化，则这里就是创建了一个两倍大小的新数组
Node[] newTab = (Node[])new Node[newCap];
// 将新的的数组赋值给成员变量table
table = newTab;
// 判断旧数组是否等于空,不等于null开始将原来的数据加入到新数组中
if (oldTab != null) {
// 遍历原数组。把每个bucket都移动到新的bucket中，遍历旧的哈希表的每个桶，重新计算桶里元素的新位置
for (int j = 0; j < oldCap; ++j) {
Node e;
// 若原数组的j位置有节点存在，才进一步操作
if ((e = oldTab[j]) != null) {
// 清除旧数组对节点的引用,方便垃圾回收
oldTab[j] = null;
// 若table数组的j位置只有一个节点，则直接将这个节点放入新数组，位置可能在新的之前的位置也肯能在旧的容量加上旧的位置
// 使用 & 替代 % 计算出余数，即下标
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;
// 若第一个节点是一个树节点，表示原数组这个位置的链表已经被转为了红黑树
// 则调用红黑树的方法将节点加入到新数组中
else if (e instanceof TreeNode)
// 将红黑树进行拆分
((TreeNode)e).split(this, newTab, j, oldCap);
// 上面两种情况都不满足，表示这个位置是一条不止一个节点的链表
// 接下来将原数组中的每一条链表的节点，放入到扩容后的新数组中
// 原数组中一条链表上的所有节点，若将它们加入到扩容后的新数组中，它们最多将会分布在新数组中的两条链表上
else { // preserve order
// 创建两个头尾节点，表示两条链表
// 因为旧链表上的元素放入新数组中，最多将变成两条链表
//loHead,loTail分别代表 **不需要移动** 的 **链头** 和 **链尾**
Node loHead = null, loTail = null;
//hiHead ,hiTail 分别代表 **需要移动** 的 **链头** 和 **链尾**
Node hiHead = null, hiTail = null;
Node next;
//循环确定原链表中每一个元素的去向，分两种情况：
//（1）要么是新索引 = 原索引 ;
//（2）要么是新索引 = 原索引 + 旧容量 ;
//因为newCap-1比oldCap-1只是多了一位1，然后通过和hash算法返回值与运算
//返回索引值，将当前元素存入对应的下标(对应的链表中)。
//再次与hash返回值与运算的时候，决定元素去留的只是最高位与运算的结果。
do {
// 记录当前节点的下一个节点
next = e.next;
// 注意：e.hash & oldCap这一步就是前面说的判断多出的这一位是否为1
// 若与原容量做与运算，结果为0，表示将这个节点放入到新数组中，下标不变
if ((e.hash & oldCap) == 0) {//jdk1.8 :尾插法
// 若这是不变链表的第一个节点，用loHead记录
if (loTail == null)//链尾为空==>首次插入，将链尾指向e
loHead = e;
// 否则，将它加入下标不变链表的尾部
else
//链尾有元素，链尾的next指向e，当有多个元素时候，while()完成链表的追加。
loTail.next = e;
// 更新尾部指针指向新加入的节点
loTail = e;
}
// 若与原容量做与运算，结果为1，表示将这个节点放入到新数组中，下标将改变
else {
// 若这是改变下标链表的第一个节点，用hiHead记录
if (hiTail == null)
hiHead = e;
// 否则，将它加入改变下标链表的尾部
else
hiTail.next = e;
// 更新尾部指针指向新加入的节点
hiTail = e;
}
} while ((e = next) != null);
//将不需要移动的链表拼接到与旧数组相同的索引（下标）位置
if (loTail != null) {
// 将这条链表的最后一个节点的next指向null
loTail.next = null;
// 同时将其放入新数组的相同位置
newTab[j] = loHead;
}
//将需要移动的链表拼接到新索引(旧索引+旧容量oldCap)位置
if (hiTail != null) {
hiTail.next = null;
// 这条链表放入的位置要在原来的基础上加上oldCap
newTab[j + oldCap] = hiHead;
}
}
}
}
}
//将新数组返回
return newTab;
}