-
6、插入
-
7、扩容
-
8、查找
-
8、删除
-
四、总结
本文基于jdk1.8
HashMap采用 key/value 存储结构，每个key对应唯一的value。
在jdk1.7之前，HashMap 的内部存储结构是数组+链表。
在jdk1.8中 HashMap的存储结构是 数组+链表+红黑树，提高了效率。
=======================================================================
在阅读HashMap源码之前，有必要对红黑树进行一些了解。
红黑树是一种自平衡二叉查找树。
红黑树具有如下特性：
-
1、 任何一个节点都有颜色，黑色或者红色
-
2、根节点是黑色的
-
3、 父子节点之间不能出现两个连续的红节点
-
4、任何一个节点向下遍历到其子孙的叶子节点，所经过的黑节点个数必须相等
-
5、空节点被认为是黑色的
红黑树是一种平衡树，让红黑树保持平衡状态主要有两种方式：旋转（左旋、右旋）和变色。
左旋和右旋的示意图如下：
变色即改变节点的颜色来保持平衡，如下图：
HashMap采用了混合式的存储结构——数组+链表+红黑树。
在添加元素时，会根据hash值算出元素在数组中的位置，如果该位置没有元素，则直接把元素放置在此处，如果该位置有元素了，则把元素以链表的形式放置在链表的尾部。
当一个链表的元素个数达到一定的数量（且数组的长度达到一定的长度）后，则把链表转化为红黑树，从而提高效率。
============================================================================
HashMap是一种基于散列表(Hash Table) 的Map，散列表是一种通用的数据结构，大部分编程语言都原生支持。
散列表的概念：key经过hash函数运算后得到一个槽（buckets或slots）的索引（index），槽中保存着要取的值。
如下图：
索引是通过散列函数计算出来的，那么不同的key可能经过散列函数计算得到相同的索引，这就产生了哈希碰撞
所以必须设计一个优秀的散列函数来降低哈希碰撞的概率。
发生哈希碰撞后也要合适地处理。
简单看一下HashMap中的hash方法：
static final int hash(Object key) {
int h;
//key.hashCode()为哈希算法，返回初始哈希值
//再做一次16位右位移异或混合
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
字符串的hashCode是一个int类型值，那可以直接作为数组下标了，且不会出现碰撞。但是这个hashCode的取值范围是[-2147483648, 2147483647]，有将近40亿的长度，所以肯定是不能作为数组下标的，内存也放不下。
默认初始化的Map大小是16个长度 DEFAULT_INITIAL_CAPACITY = 1 << 4，所以获取的Hash值并不能直接作为下标使用，需要与数组长度进行取模运算得到一个下标值。
所说义，hashMap源码这里不只是直接获取哈希值，还进行了一次扰动计算，(h = key.hashCode()) ^ (h >>> 16)。把哈希值右移16位，也就正好是自己长度的一半，之后与原哈希值做异或运算，这样就混合了原哈希值中的高位和低位，增大了随机性。
=============================================================================
还是从HashMap的继承关系看起，HashMap类图如下：
-
实现了Cloneable，可以被克隆
-
实现了Serializable，可以被序列化
-
继承自AbstractMap，实现了Map接口，具有Map的所有功能
/**
- 默认容量，必须是2的幂
**/
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; //aka16
/**
- 最大的容量为2的30次方
**/
static final int MAXIMUM_CAPACITY = 1 << 30;
/**
- 默认负载因子，值为0.75，当容量超过3/4时扩容
**/
static final float DEFAULT_LOAD_FACTOR = 0.75f;
/**
- 树化阈值：当桶中的元素个数大于8时进行树化
**/
static final int TREEIFY_THRESHOLD = 8;
/**
- 取消阈值：当一个桶中的元素个数小于等于6时把树转化为链表
**/
static final int UNTREEIFY_THRESHOLD = 6;
/**
- 最小树化阈值：当桶的个数达到64的时候才进行树化
**/
static final int MIN_TREEIFY_CAPACITY = 64;
/**
- 数组，又叫作桶（bucket）
**/
transient Node<K,V>[] table;
/**
- 作为entrySet()的缓存
*/
transient Set<Map.Entry<K,V>> entrySet;
/**
- 元素的数量
*/
transient int size;
/**
- 修改次数，用于在迭代的时候执行快速失败策略
*/
transient int modCount;
/**
- 当桶的使用数量达到多少时进行扩容，threshold = capacity * loadFactor
*/
int threshold;
/**
- 装载因子
*/
final float loadFactor;
- 容量
容量为数组的长度，亦即桶的个数，默认为16，最大为2的30次方，当容量达到64时会进行树化。
- 负载因子
负载因子用来计算容量达到多少时才进行扩容，默认负载因子为0.75。当容量超过3/4时扩容。
- 树化
树化，当容量达到64且链表的长度达到8时进行树化，当链表的长度小于6时反树化。
Node是一个典型的单链表节点，其中，hash用来存储key计算得来的hash值。
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> next;
}
上面了解了红黑树的一些性质和操作，接下来看看具体的实现。
4.1、TreeNode内部类
Node是红黑树的节点类。它继承自LinkedHashMap中的Entry类。
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);
}
/**
- 返回根节点
*/
final TreeNode<K,V> root() {
for (TreeNode<K,V> r = this, p;😉 {
if ((p = r.parent) == null)
return r;
r = p;
}
}
//……
}
4.2、左旋
/**
- 红黑树左旋操作
**/
static <K,V> TreeNode<K,V> rotateLeft(TreeNode<K,V> root,
TreeNode<K,V> p) {
TreeNode<K,V> r, pp, rl;
//p不为null且p的右子树不为null
if (p != null && (r = p.right) != null) {
//将r(p的右子树)的左子树编程p的右子树
if ((rl = p.right = r.left) != null)
//修改父节点引用，rl是r(p的右子树)的左子树
rl.parent = p;
// 将r(p的右子树)的父节点变成p的父节点（左旋过程，将右子树变成自己的父节点）
if ((pp = r.parent = p.parent) == null)
//如果p节点的父节点为null，证明p是根节点（子树的根节点）
//将r变成根节点（子树的根节点），并变成黑色（平衡）
(root = r).red = false;
//如果存在父节点且p是该节点的左子树
else if (pp.left == p)
//将r(p的右子树)变成该节点的左子树
pp.left = r;
//如果存在父节点且p节点是该节点的右子树
else
//将r(p的右子树)变成该节点的右子树
pp.right = r;
//将r(p的左子树)变成p（左旋中，将左子树变成自己的父节点）
r.left = p;
//r变成p的父节点
p.parent = r;
}
return root;
}
看一下图示。
- p没有父节点
- p有父节点
4.3、右旋
/**
- 红黑树右旋
**/
static <K,V> TreeNode<K,V> rotateRight(TreeNode<K,V> root,
TreeNode<K,V> p) {
TreeNode<K,V> l, pp, lr;
//p不为null且p的左子树不为null
if (p != null && (l = p.left) != null) {
//将l(p的左子树)的右子树变成p的左子树
if ((lr = p.left = l.right) != null)
lr.parent = p;
//将l(p的右子树)的父节点变成p的父节点（右旋过程，将左子树变成自己的父节点）
if ((pp = l.parent = p.parent) == null)
(root = l).red = false;
//如果存在父节点且p是该节点的右子树
else if (pp.right == p)
pp.right = l;
//如果存在父节点且p是该节点的左子树
else
pp.left = l;
//将l(p的右子树)变成p（右旋中，将右子树变成自己的父节点）
l.right = p;
p.parent = l;
}
return root;
}
图示如下：
- p没有父节点（可以理解为p是根节点）
- p有父节点
4.3、树化
treeify，意即树化。
前面提到了，当哈希桶中的链表长度超过阈值（默认8）的时候，就会对链表进行树化。
/**
-
红黑树化
-
@return 树的根节点
*/
final void treeify(Node<K,V>[] tab) {
TreeNode<K,V> root = null;
//循环整理
for (TreeNode<K,V> x = this, next; x != null; x = next) {
//取出下一个链表节点
next = (TreeNode<K,V>)x.next;
//将x节点的左右节点设置为null
x.left = x.right = null;
//判断当前红黑树是否有根节点
if (root == null) {
//如果没有根节点
//当前节点的父节点设置为null
x.parent = null;
//设置颜色为黑色（根节点为黑色）
x.red = false;
//将x节点设置为根节点
root = x;
}
//当前红黑树存在根节点
else {
//获取x节点的key
K k = x.key;
//获取x节点的hash
int h = x.hash;
//key的class
Class<?> kc = null;
//从根节点遍历，将x节点插入到红黑树中
for (TreeNode<K,V> p = root;😉 {
//定义dir(方向),ph(节点hash)
int dir, ph;
//取出p节点的key
K pk = p.key;
//当p节点的hash大于x节点的hash时
if ((ph = p.hash) > h)
//左侧
dir = -1;
else if (ph < h)
//右侧
dir = 1;
//如果上面的if分支没走，则证明两个节点key的hash值相等，需要通过其他方式进行比较
//如果当前节点(x)的key的类实现了comparable接口，且当前循环节点§是相同Class的实例
//那么就通过comparable进行比较
else if ((kc == null &&
(kc = comparableClassFor(k)) == null) ||
(dir = compareComparables(kc, k, pk)) == 0)
//若还是相等，就通过tieBreakOrder比较
dir = tieBreakOrder(k, pk);
//先缓存p节点
TreeNode<K,V> xp = p;
//根据dir方向，来选择在左侧还是右侧插入
//并判断是否为null
if ((p = (dir <= 0) ? p.left : p.right) == null) {
//选择的左/右子树为null
//将原来的p节点(现xp)设置为x的父节点
x.parent = xp;
//如果dir 小于等于0
//将x节点放置在原p(现xp)节点的左侧
if (dir <= 0)
xp.left = x;
//如果dir 大于0
//将x节点放置在原p(现xp)节点的右侧
xp.right = x;
//调用balanceInsertion进行插入平衡
root = balanceInsertion(root, x);
break;
}
}
}
}
//确保哈希桶指定位置存储的节点是红黑树的根节点
moveRootToFront(tab, root);
}
/**
- 确保哈希桶指定位置存储的节点是红黑树的根节点
*/
static <K,V> void moveRootToFront(Node<K,V>[] tab, TreeNode<K,V> root) {
int n;
if (root != null && tab != null && (n = tab.length) > 0) {
//索引位置
int index = (n - 1) & root.hash;
TreeNode<K,V> first = (TreeNode<K,V>)tab[index];
//如果不是红黑树的根节点
if (root != first) {
Node<K,V> rn;
//指向红黑树的根节点
tab[index] = root;
TreeNode<K,V> rp = root.prev;
//整理节点顺序
if ((rn = root.next) != null)
((TreeNode<K,V>)rn).prev = rp;
if (rp != null)
rp.next = rn;
if (first != null)
first.prev = root;
root.next = first;
root.prev = null;
}
//递归做一个恒定校验
assert checkInvariants(root);
}
}
图例如下：
4.4、插入平衡
红黑树插入节点后，需要保持平衡。
balanceInsertion就是在保持红黑树插入节点后的平衡。
保持平衡的方式是旋转和变色。
/**
- 插入平衡
*/
static <K,V> TreeNode<K,V> balanceInsertion(TreeNode<K,V> root,
TreeNode<K,V> x) {
//将x节点设为红色（新插入节点一开始为红色）
x.red = true;
//一个没有边界的循环(需要内部跳出)
for (TreeNode<K,V> xp, xpp, xppl, xppr;😉 {
//取出x的父节点并判断是否为null
if ((xp = x.parent) == null) {
//x没有父节点
x.red = false;//变色(黑色)
return x;//x为根节点发那会
}
//如果x存在父节点且x的父节点为黑色或x的父父节点不存在
else if (!xp.red || (xpp = xp.parent) == null)
//返回root
return root;
//如果x的父节点是父父节点的左孩子
if (xp == (xppl = xpp.left)) {
//父父节点的右孩子不为null且为红色
if ((xppr = xpp.right) != null && xppr.red) {
xppr.red = false;//变色(黑)
xp.red = false;//变色(黑)
xpp.red = true;//变色(红)
x = xpp;
}
else {
//x是父节点的右孩子
if (x == xp.right) {
//左旋
root = rotateLeft(root, x = xp);
//处理x的父父节点
xpp = (xp = x.parent) == null ? null : xp.parent;
}
//x的父节点存在
if (xp != null) {
xp.red = false;//变色
//x的父父节点存在
if (xpp != null) {
xpp.red = true;//变色
//右旋
root = rotateRight(root, xpp);
}
}
}
}
//如果x的父节点是父父节点的右孩子
else {
//x的父父节点的左孩子存在且为红色
if (xppl != null && xppl.red) {
xppl.red = false;//变色(黑)
xp.red = false;//变色(黑)
xpp.red = true;//变色(红)
x = xpp;
}
else {
//如果x是父节点的左孩子
if (x == xp.left) {
//右旋
root = rotateRight(root, x = xp);
//处理x的父父节点
xpp = (xp = x.parent) == null ? null : xp.parent;
}
//如果x的父节点存在
if (xp != null) {
xp.red = false;//变色(黑)
//如果x的父父节点存在
if (xpp != null) {
xpp.red = true;//变色(红)
//左旋
root = rotateLeft(root, xpp);
}
}
}
}
}
}
图例如下：
- 假如有如下一个链表，里面的数字代表hash值（先不考虑hash分布）
- 然后按照链表顺序取出节点进行红黑树插入，以及插入后平衡操作（左旋右旋/变色）
4.5、反树化
当链表的长度小于6时反树化，即红黑树退化成链表。
/**
- 红黑树链表化
*/
final Node<K,V> untreeify(HashMap<K,V> map) {
Node<K,V> hd = null, tl = null;
//循环，将红黑树转成链表
for (Node<K,V> q = this; q != null; q = q.next) {
//构造一个普通链表节点
Node<K,V> p = map.replacementNode(q, null);
//维护顺序
if (tl == null)
hd = p;
else
tl.next = p;
tl = p;
}
return hd;
}
4.6、查找
对应链表的节点查找，在链表树化后，节点的查找就是红黑树实现的。查找的逻辑还是比较清晰的，因为红黑树是自平衡二叉查找树，节点左子树都比自己小，右子树都比自己大，所以根据给定的hash，可以确定从左子树还是右子树查找，然后进行循环。
/**
- 红黑树节点查找的入口方法
*/
final TreeNode<K,V> getTreeNode(int h, Object k) {
return ((parent != null) ? root() : this).find(h, k, null);
小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。
深知大多数初中级Java工程师，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年最新Java开发全套学习资料》送给大家，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频
如果你觉得这些内容对你有帮助，可以添加下面V无偿领取！（备注Java）
最后
由于篇幅原因，就不多做展示了
s; q != null; q = q.next) {
//构造一个普通链表节点
Node<K,V> p = map.replacementNode(q, null);
//维护顺序
if (tl == null)
hd = p;
else
tl.next = p;
tl = p;
}
return hd;
}
4.6、查找
对应链表的节点查找，在链表树化后，节点的查找就是红黑树实现的。查找的逻辑还是比较清晰的，因为红黑树是自平衡二叉查找树，节点左子树都比自己小，右子树都比自己大，所以根据给定的hash，可以确定从左子树还是右子树查找，然后进行循环。
/**
- 红黑树节点查找的入口方法
*/
final TreeNode<K,V> getTreeNode(int h, Object k) {
return ((parent != null) ? root() : this).find(h, k, null);
小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。
深知大多数初中级Java工程师，想要提升技能，往往是自己摸索成长，但自己不成体系的自学效果低效又漫长，而且极易碰到天花板技术停滞不前！
因此收集整理了一份《2024年最新Java开发全套学习资料》送给大家，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
[外链图片转存中…(img-S9z903Ph-1711134555044)]
[外链图片转存中…(img-RqUx6sxR-1711134555045)]
[外链图片转存中…(img-IVrU6ER3-1711134555045)]
由于文件比较大，这里只是将部分目录截图出来，每个节点里面都包含大厂面经、学习笔记、源码讲义、实战项目、讲解视频
如果你觉得这些内容对你有帮助，可以添加下面V无偿领取！（备注Java）
[外链图片转存中…(img-xHgH4HkA-1711134555047)]
最后
[外链图片转存中…(img-yVj0zZWu-1711134555047)]
[外链图片转存中…(img-PbPbDJK2-1711134555048)]
[外链图片转存中…(img-DPh8IEVF-1711134555048)]
[外链图片转存中…(img-MuISKyVl-1711134555048)]
[外链图片转存中…(img-D4Q1yczK-1711134555049)]
[外链图片转存中…(img-fxtjmFwz-1711134555050)]
由于篇幅原因，就不多做展示了
1491
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
