简介
HashMap是以哈希表实现的Map结构, 其哈希碰撞的解决方案是链表法.
底层数据结构如图所示, table数组大于64且单链表长度大于8时, 还会转化为红黑树存储.
字段
哈希表
/**
* table数组的默认容量为16
*/
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
/**
* table数组的最大容量
*/
static final int MAXIMUM_CAPACITY = 1 << 30;
/**
* 节点数组
*/
transient Node<K, V>[] table;
/**
* table存储的元素数量
*/
transient int size;
扩容相关
/**
* 默认负载因子
*/
static final float DEFAULT_LOAD_FACTOR = 0.75f;
/**
* 负载因子
*/
final float loadFactor;
/**
* table扩容阈值
*/
int threshold;
树化相关
/**
* table数组大小超过64才会转红黑树
* 需要两个条件同时为true
*/
static final int MIN_TREEIFY_CAPACITY = 64;
/**
* 单个链表的节点数超过8,才会转红黑树
* 需要两个条件同时为true
*/
static final int TREEIFY_THRESHOLD = 8;
/**
* 红黑树退化为链表的节点数阈值
*/
static final int UNTREEIFY_THRESHOLD = 6;
构造方法
public HashMap(int initialCapacity, float loadFactor) {
// 参数校验略
this.loadFactor = loadFactor;
this.threshold = tableSizeFor(initialCapacity);
}
/**
* 将cap的值修正为大于等于cap的最近一个2的整数幂
* 例如: 16 = tableSizeFor(12)
* 0b开头表示二进制数
*/
static final int tableSizeFor(int cap) {
int n = cap - 1; // cap - 1 = 11 = n = 0b1011
n |= n >>> 1; // (0b1011 |= 0b101) = 15 = n = 0b1111
n |= n >>> 2; // (0b1111 |= 0b11) = 15 = n = 0b1111
n |= n >>> 4; // (0b1111 |= 0b0) = 15 = n = 0b1111
n |= n >>> 8; // (0b1111 |= 0b0) = 15 = n = 0b1111
n |= n >>> 16; // (0b1111 |= 0b0) = 15 = n = 0b1111
// n+1 = 16
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}
put()
public V put(K key, V value) {
int hash = hash(key);
return putVal(hash, key, value, false);
}
static final int hash(Object key) {
if (key == null) return 0;
int h = key.hashCode();
// hashcode高16位和低16位进行异或操作, 以最大程度的散列
return h ^ (h >>> 16);
}
final V putVal(int hash, K key, V value, boolean onlyIfAbsent) {
Node<K, V>[] tab;
Node<K, V> p;
int n, i;
if ((tab = table) == null || (n = tab.length) == 0) {
n = (tab = resize()).length; // table为空, resize初始化
}
i = (n - 1) & hash; // 计算出要插入的位置, 思考为什么不是hash%n
if ((p = tab[i]) == null) { // 当前i位置还未插入过节点, 则创建新节点
tab[i] = newNode(hash, key, value, null);
} else {
// 当前i位置已存在节点
Node<K, V> e;
K k;
if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) {
e = p; // key相同时
} else if (p instanceof TreeNode) { // 链表已转为红黑树, 执行树中的putVal
e = ((TreeNode<K, V>) p).putTreeVal(this, tab, hash, key, value);
} else {
for (int binCount = 0; ; ++binCount) { // 遍历链表
if ((e = p.next) == null) { // e为null, 则p是链表尾节点
// 将当前节点插入到p之后
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) {
treeifyBin(tab, hash); // 链表树化
}
break;
}
// 一次循环中, 找到了与当前节点相同的key
if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) break;
p = e;
}
}
if (e != null) { // key相同的旧节点
V oldValue = e.value;
// 是否需要覆盖数据
if (!onlyIfAbsent || oldValue == null) e.value = value;
return oldValue;
}
}
++modCount;
if (++size > threshold) resize(); // 是否需要扩容
return null;
}
resize() 扩容
final Node<K, V>[] resize() {
Node<K, V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
if (oldCap > 0) {
if (oldCap >= MAXIMUM_CAPACITY) {
// 容量已达最大值, 无法扩容了, 放开阈值限制, 可以继续在旧table添加元素
threshold = Integer.MAX_VALUE;
return oldTab; // 提前返回旧table
} else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // 两倍容量扩容
} else if (oldThr > 0) newCap = oldThr;
else { // 初始化逻辑
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (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;
Node<K, V>[] newTab = (Node<K, V>[]) new Node[newCap];
table = newTab;
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) { //遍历旧table
Node<K, V> e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
if (e.next == null) {
// 链表只有一个节点, 直接放入新table
newTab[e.hash & (newCap - 1)] = e;
} else if (e instanceof TreeNode) {
((TreeNode<K, V>) e).split(this, newTab, j, oldCap);
} else { // preserve order
// 扩容后的位置还是j
Node<K, V> loHead = null, loTail = null;
// 扩容后的位置为j+oldCap
Node<K, V> hiHead = null, hiTail = null;
Node<K, V> next;
do {
next = e.next;
// 根据e.hash的最高位是否为0 把原链表拆分为两段
if ((e.hash & oldCap) == 0) { // 节点的hash小于oldCap, 链到lo中
if (loTail == null) loHead = e;
else loTail.next = e;
loTail = e;
} else { // 节点的hash大于oldCap, 链到hi中
if (hiTail == null) hiHead = e;
else hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
// 分别将lo链表和hi链表保存到新table中,
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
treeifyBin() 链表树化
final void treeifyBin(Node<K, V>[] tab, int hash) {
int n, index;
Node<K, V> e;
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
// 若table数组容量小于64, 则还是走扩容,先不执行树化过程, 此举也能将节点较多的链表拆散
resize();
else if ((e = tab[index = (n - 1) & hash]) != null) {
TreeNode<K, V> hd = null, tl = null;
do {
// 循环的作用是将链表复制一份出来
// 新链表的node类型虽然是tree,但暂时还是以链表形式组织在一起
TreeNode<K, V> p = replacementTreeNode(e, null);
if (tl == null) hd = p;
else {
p.prev = tl;
tl.next = p;
}
tl = p;
} while ((e = e.next) != null);
// 将新链表头放入tab[index]中
if ((tab[index] = hd) != null)
// 新链表树化
hd.treeify(tab);
}
}
TreeNode<K, V> replacementTreeNode(Node<K, V> p, Node<K, V> next) {
return new TreeNode<>(p.hash, p.key, p.value, next);
}
final void treeify(Node<K, V>[] tab) {
TreeNode<K, V> root = null; //红黑树的root节点
// this即为要树化的链表, 循环遍历链表, 将每个链表节点插入到root树中
for (TreeNode<K, V> x = this, next; x != null; x = next) {
// 备份下一节点
next = (TreeNode<K, V>) x.next;
x.left = x.right = null;
if (root == null) { // 根节点颜色必为黑, 红黑树性质
x.parent = null;
x.red = false;
root = x;
} else { // 非根节点
K k = x.key;
int h = x.hash;
Class<?> kc = null;
for (TreeNode<K, V> p = root; ; ) { // 遍历红黑树, 找到可插入的位置
// 判断当前节点和要插入的节点的大小序,类似Comparable功能的逻辑
int dir, ph;
K pk = p.key;
if ((ph = p.hash) > h) dir = -1;
else if (ph < h) dir = 1;
else if ((kc == null && (kc = comparableClassFor(k)) == null) || (dir = compareComparables(kc, k, pk)) == 0)
dir = tieBreakOrder(k, pk);
TreeNode<K, V> xp = p; // 备份p
// 二叉树性质: left < p < right
// 根据dir结果, 判断是插入到p的左边还是右边, 且插入的位置要是null
if ((p = (dir <= 0) ? p.left : p.right) == null) {
// 节点插入
x.parent = xp;
if (dir <= 0) xp.left = x;
else xp.right = x;
// 保持平衡
root = balanceInsertion(root, x);
break;
}
}
}
}
// 将树根节点放到tab[i]中,原来存放的是链表的head
moveRootToFront(tab, root);
}
balanceInsertion() 红黑树插入后的平衡
static <K, V> TreeNode<K, V> balanceInsertion(TreeNode<K, V> root, TreeNode<K, V> x) {
// 定义
// 0. 新节点默认是红色
// 1. 根节点为黑色
// 2. 不存在的叶子节点都视为黑色
// 3. 红节点的父/子都必为黑
// 4. 节点到所有叶子中的黑节点数量一致
// 调整策略, 当父节点为红色时(双红缺陷) 策略的调整就是为了保持定义
// 1. 叔为红: 父和叔都染黑,祖父染红, 然后关注祖父是否引起了失衡(双红缺陷)
// 2. 叔为黑 叔和节点的方向一致, 即都为左子或右子;
// 2.1 需要父向外旋转, 即左子时右旋、右子时左旋
// 2.2 旋转后原父子节点关系变成子父关系, 关注点也由原来的子变原来的父
// 2.3 然后就会变成策略3
// 3. 叔为黑 叔和节点的方向不一致
// 3.1 父染黑、祖父染红
// 3.2 祖父节点外旋, 即左子时祖父右旋、右子时祖父左旋
x.red = true; // 符合定义定义0
// xp, 当前插入节点的父亲
// xpp:祖父 xppl:左叔父 xppr:右叔父
for (TreeNode<K, V> xp, xpp, xppl, xppr; ; ) {
if ((xp = x.parent) == null) { // 新节点被插入成root, 则染黑并返回
x.red = false;
return x;
} else if (!xp.red || (xpp = xp.parent) == null) {
// 父节点是黑色, 可以直接返回, 符合定义4
// (此条件非必要? 若父为红, 则parent必不空)
return root;
}
// 走到这, 说明父节点为红色, 因为当前节点也为红色, 违反定义3, 需要重平衡
if (xp == (xppl = xpp.left)) {
if ((xppr = xpp.right) != null && xppr.red) { // 父、右叔父都为红?
// 策略1
xppr.red = false;
xp.red = false;
xpp.red = true;
// 继续关注变红了的祖父是否会引起失衡
x = xpp;
} else { // 父为红, 右叔父为黑
if (x == xp.right) {
// 策略2, 围绕父节点左旋
root = rotateLeft(root, x = xp);
xpp = (xp = x.parent) == null ? null : xp.parent;
}
if (xp != null) {
// 策略3, 父染黑、祖父染红
xp.red = false;
if (xpp != null) {
xpp.red = true;
// 围绕祖父节点右旋
root = rotateRight(root, xpp);
}
}
}
} else {
if (xppl != null && xppl.red) { // 父、左叔父都为红?
// 策略1
xppl.red = false;
xp.red = false;
xpp.red = true;
// 继续关注变红了的祖父是否会引起失衡
x = xpp;
} else { // 父为红, 左叔父为黑
if (x == xp.left) {
// 策略2, 围绕父节点右旋
root = rotateRight(root, x = xp);
xpp = (xp = x.parent) == null ? null : xp.parent;
}
if (xp != null) {
// 策略3, 父染黑、祖父染红
xp.red = false;
if (xpp != null) {
xpp.red = true;
// 围绕祖父节点左旋
root = rotateLeft(root, xpp);
}
}
}
}
}
}
remove()
public V remove(Object key) {
int hash = hash(key);
Node<K, V> e = removeNode(hash, key, null, false, true);
return e == 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;
if ((tab = table) != null && (n = tab.length) > 0 && (p = tab[index = (n - 1) & hash]) != null) {
// 散列表不为空 && table[i]处节点p不为空
Node<K, V> node = null, e;
K k;
V v;
// 查找节点
if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) {
// 链表头恰好是要删除的节点
node = p;
} else if ((e = p.next) != null) {
if (p instanceof TreeNode) {
// 链表已树化
node = ((TreeNode<K, V>) p).getTreeNode(hash, key);
} else {
do { // 遍历链表, 寻找要删除的节点
if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) {
node = e; // 找到节点
break;
}
p = e; // p代表pre
} while ((e = e.next) != null); // 转到next
}
}
// 删除节点
if (node != null && (!matchValue || (v = node.value) == value || (value != null && value.equals(v)))) {
if (node instanceof TreeNode) { // 树的删除
((TreeNode<K, V>) node).removeTreeNode(this, tab, movable);
} else if (node == p) { // node是之前链表的头节点
tab[index] = node.next;
} else {
// 删除node的引用
p.next = node.next;
}
++modCount;
--size;
afterNodeRemoval(node);
return node;
}
}
return null;
}
