HashMap源码阅读笔记
【摘要】
文章目录
一、红黑树1、红黑树的性质2、 红黑树平衡操作3、HashMap中的红黑树
二、散列(Hash)1、 散列表(Hash Table)2、散列函数(Hash函数)
三、HashMap源码1、HashMap继承关系2、HashMap属性3、Node内部类4、红黑树相关4.1、TreeNode内部类4.2、左旋4.3、右旋4.3、树化4.4、插入平衡...
本文基于jdk1.8
HashMap采用 key/value 存储结构，每个key对应唯一的value。
在jdk1.7之前，HashMap 的内部存储结构是数组+链表。
在jdk1.8中 HashMap的存储结构是 数组+链表+红黑树，提高了效率。
一、红黑树
在阅读HashMap源码之前，有必要对红黑树进行一些了解。
1、红黑树的性质
红黑树是一种自平衡二叉查找树。
红黑树具有如下特性：
- 1、 任何一个节点都有颜色，黑色或者红色
- 2、根节点是黑色的
- 3、 父子节点之间不能出现两个连续的红节点
- 4、任何一个节点向下遍历到其子孙的叶子节点，所经过的黑节点个数必须相等
- 5、空节点被认为是黑色的
2、 红黑树平衡操作
红黑树是一种平衡树，让红黑树保持平衡状态主要有两种方式：旋转（左旋、右旋）和变色。
左旋和右旋的示意图如下：
变色即改变节点的颜色来保持平衡，如下图：
3、HashMap中的红黑树
HashMap采用了混合式的存储结构——数组+链表+红黑树。
在添加元素时，会根据hash值算出元素在数组中的位置，如果该位置没有元素，则直接把元素放置在此处，如果该位置有元素了，则把元素以链表的形式放置在链表的尾部。
当一个链表的元素个数达到一定的数量（且数组的长度达到一定的长度）后，则把链表转化为红黑树，从而提高效率。
二、散列(Hash)
1、 散列表(Hash Table)
HashMap是一种基于散列表(Hash Table) 的Map，散列表是一种通用的数据结构，大部分编程语言都原生支持。
散列表的概念：key经过hash函数运算后得到一个槽（buckets或slots）的索引（index），槽中保存着要取的值。
如下图：
2、散列函数(Hash函数)
索引是通过散列函数计算出来的，那么不同的key可能经过散列函数计算得到相同的索引，这就产生了哈希碰撞
所以必须设计一个优秀的散列函数来降低哈希碰撞的概率。
发生哈希碰撞后也要合适地处理。
简单看一下HashMap中的hash方法：
static final int hash(Object key) { int h; //key.hashCode()为哈希算法，返回初始哈希值 //再做一次16位右位移异或混合 return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16); }
- 1
- 2
- 3
- 4
- 5
- 6
字符串的hashCode是一个int类型值，那可以直接作为数组下标了，且不会出现碰撞。但是这个hashCode的取值范围是[-2147483648, 2147483647]，有将近40亿的长度，所以肯定是不能作为数组下标的，内存也放不下。
默认初始化的Map大小是16个长度 DEFAULT_INITIAL_CAPACITY = 1 << 4，所以获取的Hash值并不能直接作为下标使用，需要与数组长度进行取模运算得到一个下标值。
所说义，hashMap源码这里不只是直接获取哈希值，还进行了一次扰动计算，(h = key.hashCode()) ^ (h >>> 16)。把哈希值右移16位，也就正好是自己长度的一半，之后与原哈希值做异或运算，这样就混合了原哈希值中的高位和低位，增大了随机性。
三、HashMap源码
1、HashMap继承关系
还是从HashMap的继承关系看起，HashMap类图如下：
- 实现了Cloneable，可以被克隆
- 实现了Serializable，可以被序列化
- 继承自AbstractMap，实现了Map接口，具有Map的所有功能
2、HashMap属性
/**
* 默认容量，必须是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;
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
-
容量
容量为数组的长度，亦即桶的个数，默认为16，最大为2的30次方，当容量达到64时会进行树化。 -
负载因子
负载因子用来计算容量达到多少时才进行扩容，默认负载因子为0.75。当容量超过3/4时扩容。 -
树化
树化，当容量达到64且链表的长度达到8时进行树化，当链表的长度小于6时反树化。
3、Node内部类
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;
}
- 1
- 2
- 3
- 4
- 5
- 6
4、红黑树相关
上面了解了红黑树的一些性质和操作，接下来看看具体的实现。
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; } } //……
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
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; }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
看一下图示。
-
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; }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
图示如下：
- 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接口，且当前循环节点(p)是相同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); }
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
- 100
- 101
- 102
- 103
- 104
- 105
- 106
- 107
- 108
- 109
- 110
- 111
图例如下：
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); } } } } }
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
图例如下：
- 假如有如下一个链表，里面的数字代表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;
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
4.6、查找
对应链表的节点查找，在链表树化后，节点的查找就是红黑树实现的。查找的逻辑还是比较清晰的，因为红黑树是自平衡二叉查找树，节点左子树都比自己小，右子树都比自己大，所以根据给定的hash，可以确定从左子树还是右子树查找，然后进行循环。
/**
* 红黑树节点查找的入口方法
*/
final TreeNode<K,V> getTreeNode(int h, Object k) { return ((parent != null) ? root() : this).find(h, k, null);
}
/**
* 根据给定的hash和key，从红黑树的根节点开始进行查找
*/
final TreeNode<K,V> find(int h, Object k, Class<?> kc) { TreeNode<K,V> p = this; do { int ph, dir; K pk; //取出左子树和右子树，根据hash和key进行查找 TreeNode<K,V> pl = p.left, pr = p.right, q; //根据hash大小决定取左子树还是右子树 if ((ph = p.hash) > h) p = pl; else if (ph < h) p = pr; //如果在节点相等，就返回 else if ((pk = p.key) == k || (k != null && k.equals(pk))) return p; else if (pl == null) p = pr; else if (pr == null) p = pl; else if ((kc != null || (kc = comparableClassFor(k)) != null) && (dir = compareComparables(kc, k, pk)) != 0) p = (dir < 0) ? pl : pr; else if ((q = pr.find(h, k, kc)) != null) return q; else p = pl; } while (p != null); return null;
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
4.7、删除节点
删除节点的操作还是比较麻烦，因为删除之后需要平衡红黑树。
/**
* 移除给定节点, 调用该方法时要确保节点存在.
* 因为无法交换存在叶子节点的内部节点内容，所以这会比典型的红黑树节点删除来得复杂
* 遍历过程中"next"指针指向的继任节点是可访问的，所以我们交换了树的连接.
* 如果当前树节点太少，则将二叉树替换成简单形式
* (2-6节点测试触发，取决于树的结构)
*/
final void removeTreeNode(HashMap<K,V> map, Node<K,V>[] tab, boolean movable) { int n; //判断哈希桶 if (tab == null || (n = tab.length) == 0) return; //下标 int index = (n - 1) & hash; //取出指定下标的根节点 TreeNode<K,V> first = (TreeNode<K,V>)tab[index], root = first, rl; //继任节点和前置节点 TreeNode<K,V> succ = (TreeNode<K,V>)next, pred = prev; //前置节点不存在，则证明要移除的节点是根节点 if (pred == null) //将继任节点往前移 tab[index] = first = succ; else //前置节点存在，则将继任节点连接到前置节点（移除本节点） pred.next = succ; //判断继任节点是否存在 if (succ != null) //存在的话，修改前置引用 succ.prev = pred; //这个时候first为null，则表示哈希桶指定位置可能只有一个节点 if (first == null) //返回 return; //获取根节点 if (root.parent != null) root = root.root(); //根节点不存在或者根节点的左子树/右子树不存在或者左左子树不存在 //该判断是作为链表化的阈值 if (root == null || root.right == null || (rl = root.left) == null || rl.left == null) { //红黑树太小，进行链表化 tab[index] = first.untreeify(map); // too small return; } //取得要移除的节点，左子树，右子树 TreeNode<K,V> p = this, pl = left, pr = right, replacement; //左右子树同时存在 if (pl != null && pr != null) { TreeNode<K,V> s = pr, sl; //循环查找继任节点 while ((sl = s.left) != null) // find successor s = sl; //交换p和s的颜色 boolean c = s.red; s.red = p.red; p.red = c; // swap colors TreeNode<K,V> sr = s.right; TreeNode<K,V> pp = p.parent; //相等则证明p是s的直接父节点（只有一个层级） if (s == pr) { // p was s's direct parent //交换位置 p.parent = s; s.right = p; } //如果是多个层级 else { //取出s的父节点 TreeNode<K,V> sp = s.parent; //下面操作仍然是交换p和s的位置 if ((p.parent = sp) != null) { if (s == sp.left) sp.left = p; else sp.right = p; } if ((s.right = pr) != null) pr.parent = s; } //清空p的右子树引用 p.left = null; //调整相关引用 if ((p.right = sr) != null) sr.parent = p; if ((s.left = pl) != null) pl.parent = s; if ((s.parent = pp) == null) root = s; else if (p == pp.left) pp.left = s; else pp.right = s; //确定替换节点 if (sr != null) replacement = sr; else replacement = p; } //只有左子树存在 else if (pl != null) replacement = pl; //只有右子树存在 else if (pr != null) replacement = pr; //左右子树都不存在 else replacement = p; //判断替换的节点是不是自身 if (replacement != p) { //不是自身的话，则执行相关替换操作 TreeNode<K,V> pp = replacement.parent = p.parent; if (pp == null) root = replacement; else if (p == pp.left) pp.left = replacement; else pp.right = replacement; p.left = p.right = p.parent = null; } //判断p的颜色 //如果p是红色节点，则将根节点赋值给r //如果p是黑色节点，则进行删除平衡(类似于插入平衡) //这里的r要存储红黑树的根节点 TreeNode<K,V> r = p.red ? root : balanceDeletion(root, replacement); //如果替换节点是自身的话 if (replacement == p) { // detach //进行分离操作 TreeNode<K,V> pp = p.parent; p.parent = null; if (pp != null) { if (p == pp.left) pp.left = null; else if (p == pp.right) pp.right = null; } } if (movable) //确保哈希桶下标指定位置存储的是红黑树根节点 moveRootToFront(tab, r);
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
- 100
- 101
- 102
- 103
- 104
- 105
- 106
- 107
- 108
- 109
- 110
- 111
- 112
- 113
- 114
- 115
- 116
- 117
- 118
- 119
- 120
- 121
- 122
- 123
- 124
- 125
- 126
- 127
- 128
- 129
- 130
- 131
- 132
- 133
- 134
- 135
- 136
- 137
- 138
5、HashMap构造方法
- 无参构造方法：
/** * 所有参数使用默认值 */ public HashMap() { this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted }
- 1
- 2
- 3
- 4
- 5
- 6
- HashMap(int initialCapacity)：指定默认装载因子
public HashMap(int initialCapacity) { this(initialCapacity, DEFAULT_LOAD_FACTOR); }
- 1
- 2
- 3
- HashMap(int initialCapacity, float loadFactor)：判断传入的初始容量和装载因子是否合法，并计算扩容门槛，扩容门槛为传入的初始容量往上取最近的2的n次方
public HashMap(int initialCapacity, float loadFactor) { // 检查传入的初始容量是否合法 if (initialCapacity < 0) throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity); if (initialCapacity > MAXIMUM_CAPACITY) initialCapacity = MAXIMUM_CAPACITY; // 检查装载因子是否合法 if (loadFactor <= 0 || Float.isNaN(loadFactor)) throw new IllegalArgumentException("Illegal load factor: " + loadFactor); this.loadFactor = loadFactor; // 计算扩容门槛 this.threshold = tableSizeFor(initialCapacity);
}
static final int tableSizeFor(int cap) { // 扩容门槛为传入的初始容量往上取最近的2的n次方 int n = cap - 1; n |= n >>> 1; n |= n >>> 2; n |= n >>> 4; n |= n >>> 8; n |= n >>> 16; return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
6、插入
HashMap插入的流程图如下：
public V put(K key, V value) { //调用hash(key)计算出key的hash值 return putVal(hash(key), key, value, false, true); } 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，table 被延迟到插入新数据时再进行初始化 if ((tab = table) == null || (n = tab.length) == 0) // 调用resize()初始化 n = (tab = resize()).length; // (n - 1) & hash 计算元素在哪个桶中 // 如果这个桶中还没有元素，则把这个元素放在桶中的第一个位置 if ((p = tab[i = (n - 1) & hash]) == null) //新建一个节点放在桶中 tab[i] = newNode(hash, key, value, null); else { //如果桶中已经有元素存在了 Node<K,V> e; K k; // 如果桶中第一个元素的key与待插入元素的key相同，保存到e中用于后续修改value值 if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) e = p; else if (p instanceof TreeNode) // 如果第一个元素是树节点，则调用树节点的putTreeVal插入元素 e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value); else { // 遍历这个桶对应的链表，binCount用于存储链表中元素的个数 for (int binCount = 0; ; ++binCount) { // 如果链表遍历完了都没有找到相同key的元素，说明该key对应的元素不存在，则在链表最后插入一个新节点 if ((e = p.next) == null) { p.next = newNode(hash, key, value, null); // 如果插入新节点后链表长度大于8，则判断是否需要树化，因为第一个元素没有加到binCount中，所以这里-1 if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st treeifyBin(tab, hash); break; } // 如果待插入的key在链表中找到了，则退出循环 if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) break; p = e; } } // 如果找到了对应key的元素 if (e != null) { // existing mapping for key // 记录下旧值 V oldValue = e.value; // 判断是否需要替换旧值 if (!onlyIfAbsent || oldValue == null) // 替换旧值为新值 e.value = value; afterNodeAccess(e); // 返回旧值 return oldValue; } } // 到这里了说明没有找到元素 // 修改次数加1 ++modCount; // 元素数量加1，判断是否需要扩容 if (++size > threshold) // 扩容 resize(); afterNodeInsertion(evict); return null; }
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
插入：
- 1、首先进行哈希值的扰动，获取一个新的哈希值。
- 2、判断tab是否位空或者长度为0，如果是则进行扩容操作
- 3、根据哈希值计算下标，如果对应小标正好没有存放数据，则直接插入即可，否则需要覆盖。
- 4、判断tab[i]是否为树节点，否则向链表中插入数据，是则向树中插入节点。
- 5、如果链表中插入节点的时候，链表长度大于等于8，则需要把链表转换为红黑树。
- 6、最后所有元素处理完成后，判断是否超过阈值；threshold，超过则扩容。
- 7、treeifyBin,是一个链表转树的方法，但不是所有的链表长度为8后都会转成树，还需要判断存放key值的数组桶长度是否小于64 （MIN_TREEIFY_CAPACITY）。如果小于则需要扩容，扩容后链表上的数据会被拆分散列的相应的桶节点上，也就把链表长度缩短了。
7、扩容
HashMap是基于数组+链表和红黑树实现的，但用于存放key值得的数组桶的长度是固定的，由初始化决定。
那么，随着数据的插入数量增加以及负载因子的作用下，就需要扩容来存放更多的数据。
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) { // 如果旧容量达到了最大容量，则不再进行扩容 threshold = Integer.MAX_VALUE; return oldTab; } else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY) // 如果旧容量的两倍小于最大容量并且旧容量大于默认初始容量（16），则容量扩大为两部，扩容门槛也扩大为两倍 newThr = oldThr << 1; // double threshold } else if (oldThr > 0) // initial capacity was placed in threshold // 使用非默认构造方法创建的map，第一次插入元素会走到这里 // 如果旧容量为0且旧扩容门槛大于0，则把新容量赋值为旧门槛 newCap = oldThr; else { // zero initial threshold signifies using defaults // 调用默认构造方法创建的map，第一次插入元素会走到这里 // 如果旧容量旧扩容门槛都是0，说明还未初始化过，则初始化容量为默认容量，扩容门槛为默认容量*默认装载因子 newCap = DEFAULT_INITIAL_CAPACITY; newThr = (int) (DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); } if (newThr == 0) { // 如果新扩容门槛为0，则计算为容量*装载因子，但不能超过最大容量 float ft = (float) newCap * loadFactor; newThr = (newCap < MAXIMUM_CAPACITY && ft < (float) MAXIMUM_CAPACITY ? (int) ft : Integer.MAX_VALUE); } // 赋值扩容门槛为新门槛 threshold = newThr; // 新建一个新容量的数组 @SuppressWarnings({"rawtypes", "unchecked"}) Node<K, V>[] newTab = (Node<K, V>[]) new Node[newCap]; // 把桶赋值为新数组 table = newTab; // 如果旧数组不为空，则搬移元素 if (oldTab != null) { // 遍历旧数组 for (int j = 0; j < oldCap; ++j) { Node<K, V> e; // 如果桶中第一个元素不为空，赋值给e if ((e = oldTab[j]) != null) { // 清空旧桶，便于GC回收 oldTab[j] = null; // 如果这个桶中只有一个元素，则计算它在新桶中的位置并把它搬移到新桶中 // 因为每次都扩容两倍，所以这里的第一个元素搬移到新桶的时候新桶肯定还没有元素 if (e.next == null) newTab[e.hash & (newCap - 1)] = e; else if (e instanceof TreeNode) // 如果第一个元素是树节点，则把这颗树打散成两颗树插入到新桶中去 ((TreeNode<K, V>) e).split(this, newTab, j, oldCap); else { // preserve order // 如果这个链表不止一个元素且不是一颗树 // 则分化成两个链表插入到新的桶中去 // 比如，假如原来容量为4，3、7、11、15这四个元素都在三号桶中 // 现在扩容到8，则3和11还是在三号桶，7和15要搬移到七号桶中去 // 也就是分化成了两个链表 Node<K, V> loHead = null, loTail = null; Node<K, V> hiHead = null, hiTail = null; Node<K, V> next; do { next = e.next; // (e.hash & oldCap) == 0的元素放在低位链表中 // 比如，3 & 4 == 0 if ((e.hash & oldCap) == 0) { if (loTail == null) loHead = e; else loTail.next = e; loTail = e; } else { // (e.hash & oldCap) != 0的元素放在高位链表中 // 比如，7 & 4 != 0 if (hiTail == null) hiHead = e; else hiTail.next = e; hiTail = e; } } while ((e = next) != null); // 遍历完成分化成两个链表了 // 低位链表在新桶中的位置与旧桶一样（即3和11还在三号桶中） if (loTail != null) { loTail.next = null; newTab[j] = loHead; } // 高位链表在新桶中的位置正好是原来的位置加上旧容量（即7和15搬移到七号桶了） if (hiTail != null) { hiTail.next = null; newTab[j + oldCap] = hiHead; } } } } } return newTab;
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
- 57
- 58
- 59
- 60
- 61
- 62
- 63
- 64
- 65
- 66
- 67
- 68
- 69
- 70
- 71
- 72
- 73
- 74
- 75
- 76
- 77
- 78
- 79
- 80
- 81
- 82
- 83
- 84
- 85
- 86
- 87
- 88
- 89
- 90
- 91
- 92
- 93
- 94
- 95
- 96
- 97
- 98
- 99
- 100
- 101
- 102
扩容：
-
（1）如果使用是默认构造方法，则第一次插入元素时初始化为默认值，容量为16，扩容门槛为12；
-
（2）如果使用的是非默认构造方法，则第一次插入元素时初始化容量等于扩容门槛，扩容门槛在构造方法里等于传入容量向上最近的2的n次方；
-
（3）如果旧容量大于0，则新容量等于旧容量的2倍，但不超过最大容量2的30次方，新扩容门槛为旧扩容门槛的2倍；
-
（4）创建一个新容量的桶；
-
（5）搬移元素，原链表分化成两个链表，低位链表存储在原来桶的位置，高位链表搬移到原来桶的位置加旧容量的位置
8、查找
public V get(Object key) { Node<K, V> e; return (e = getNode(hash(key), key)) == null ? null : e.value;
}
final Node<K, V> getNode(int hash, Object key) { Node<K, V>[] tab; Node<K, V> first, e; int n; K k; // 如果桶的数量大于0并且待查找的key所在的桶的第一个元素不为空 if ((tab = table) != null && (n = tab.length) > 0 && (first = tab[(n - 1) & hash]) != null) { // 检查第一个元素是不是要查的元素，如果是直接返回 if (first.hash == hash && // always check first node ((k = first.key) == key || (key != null && key.equals(k)))) return first; if ((e = first.next) != null) { // 如果第一个元素是树节点，则按树的方式查找 if (first instanceof TreeNode) return ((TreeNode<K, V>) first).getTreeNode(hash, key); // 否则就遍历整个链表查找该元素 do { if (e.hash == hash && ((k = e.key) == key || (key != null && key.equals(k)))) return e; } while ((e = e.next) != null); } } return null;
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
查找：
-
（1）计算key的hash值；
-
（2）找到key所在的桶及其第一个元素；
-
（3）如果第一个元素的key等于待查找的key，直接返回；
-
（4）如果第一个元素是树节点就按树的方式来查找，否则按链表方式查找；
8、删除
public V remove(Object key) { Node<K,V> e; return (e = removeNode(hash(key), key, null, false, true)) == 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; // 定位桶数组中的下标位置，index = (n - 1) & hash if ((tab = table) != null && (n = tab.length) > 0 && (p = tab[index = (n - 1) & hash]) != null) { Node<K,V> node = null, e; K k; V v; // 如果键的值与链表第一个节点相等，则将 node 指向该节点 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; } while ((e = e.next) != null); } } // 删除节点，以及红黑树需要修复，因为删除后会破坏平衡性。链表的删除更加简单。 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) tab[index] = node.next; else p.next = node.next; ++modCount; --size; afterNodeRemoval(node); return node; } } return null;
}
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
四、总结
- HashMap是一种散列表，采用（数组 + 链表 + 红黑树）的存储结构
- HashMap的默认初始容量为16（1<<4），默认装载因子为0.75f，容量总是2的n次方
- HashMap扩容时每次容量变为原来的两倍
- 当桶的数量小于64时不会进行树化，只会扩容
- 当桶的数量大于64且单个桶中元素的数量大于8时，进行树化
- 当单个桶中元素数量小于6时，进行反树化
- HashMap是非线程安全的
- HashMap查找添加元素的时间复杂度都为O(1)
本文为学习笔记，参考资料如下！
参考：
【1】：【死磕 Java 集合】— HashMap源码分析
【2】：HashMap源码阅读
【3】：面经手册 · 第3篇《HashMap核心知识，扰动函数、负载因子、扩容链表拆分，深度学习》
【4】：面经手册 · 第4篇《HashMap数据插入、查找、删除、遍历，源码分析》
【5】：面经手册 · 第5篇《看图说话，讲解2-3平衡树「红黑树的前身」》
【6】：面经手册 · 第6篇《带着面试题学习红黑树操作原理，解析什么时候染色、怎么进行旋转、与2-3树有什么关联》
【7】：Java源码阅读之红黑树在HashMap中的应用 - JDK1.8
【8】：Java HashMap 源码解析
【9】：重学数据结构（六、树和二叉树）
【10】：红黑树深入剖析及Java实现
【11】：哈希碰撞与生日攻击
文章来源: blog.csdn.net，作者：三分恶，版权归原作者所有，如需转载，请联系作者。
原文链接：blog.csdn.net/sinat_40770656/article/details/109231408
【版权声明】本文为华为云社区用户转载文章，如果您发现本社区中有涉嫌抄袭的内容，欢迎发送邮件进行举报，并提供相关证据，一经查实，本社区将立刻删除涉嫌侵权内容，举报邮箱：
cloudbbs@huaweicloud.com
- 点赞
- 收藏
- 关注作者
评论（0）