相关文章:
HashMap 是我们日常开发过程中使用的最多的集合类之一,最早出现在 JDK2 中,以 key、value 的形式保存具有映射关系的两个数据 (由 key、value 两个值组成的键值对),其中 key 是不可重复的,value 是可重复的,key 和 value 都可以存放 null,但 key 只能存在一个 null,value 可以存在一个或多个 null
简单地了解了 HashMap 后,让我们来深入了解下它的底层实现原理
一、数据结构
-
在 JDK8 之前的版本中,HashMap 底层采用了数组 + 链表的数据结构
-
数组
-
数组是内存中一块连续的存储空间,因此我们可以通过下标快速地定位到数组中的任何元素
-
当往数组中插入或删除元素时,需要移动其他元素,此外,如果没有足够的空间 (数组无法动态扩容),还需要将整个数组的元素复制到另外一个数组中
-
总结下来就是:遍历查找元素效率高,添加删除元素效率低
-
-
链表
-
链表是内存中一块不连续的存储空间,元素与元素之间通过指针关联到一起
-
当往链表中添加除元素时,需要将插入点前的元素的指针指向该元素,并将该元素的指针指向插入点后的元素
-
当往链表中删除除元素时,需要将删除点前的元素的指针指向删除点后的元素
-
当在链表中查询数据时,需要遍历整个链表,才能找到想要的元素
-
总结下来就是:遍历查询元素效率低,添加删除元素效率高
-
-
数组和链表操作的时间复杂度如下所示
操作 数组 链表 读取 O(1) O(n) 插入 O(n) O(1) 删除 O(n) O(1)
-
-
在 JDK8 及之后的版本中,HashMap 底层采用了数组 + 链表 + 红黑树的数据结构,当链表长度大于等于阈值 8 时,会将链表转换为红黑树
-
数组和链表各有其优缺点,那么能不能结合两者的特性,得到一个查询、添加和删除效率都高的数据结构呢?答案是肯定的,这就是我们现在要提到的哈希表
-
哈希表
-
哈希表 (Hash table,也叫散列表),是根据关键码值 (key、value) 而直接访问的数据结构,也就是说,它通过把关键码值映射到表中一个位置来访问记录,以加快查询的速度,这个映射函数叫做散列函数,存放记录的数组叫做散列表
-
给定表 M,存在函数 f(key),对任意给定的关键字值 key,代入函数后能得到包含该关键字的记录在表中的地址,则称表 M 为哈希表,函数 f(key) 为哈希函数
-
-
哈希冲突
- 哈希冲突,也称哈希碰撞,对不同的关键字使用哈希函数进行运算,可能会得到相同的散列地址,这种现象即为哈希冲突
-
哈希冲突的解决方法
-
开放地址法
- 当发生冲突时,继续寻找下一块未被占用的存储地址
-
再散列法
- 当发生冲突时,使用另一个哈希函数计算地址,直到冲突不再发生,这种方法不易产生"聚集",但增加了计算时间
-
链地址法 (拉链法)
- 即数组 + 链表的方式,HashMap 就是采用该方法来解决哈希冲突
-
-
二、示意图
-
数组 + 链表 (JDK 8 之前版本)
-
数组 + 链表 + 红黑树 (JDK 8 及之后版本)
-
如上所示,HashMap 底层数组长度默认为 16,数组中每个元素存储的是对应链表的头节点,这种元素 + 链表的结构我们也可称之为哈希桶
-
节点先通过
(n - 1) & hash
(n 为数组长度) 运算来定位哈希桶的索引位置,然后再将自身存放至桶中-
(n - 1) & hash
运算等价于hash % n
,即在取模操作中,如果除数是 2 的幂次方,则等价于与其除数减一的 & 操作,也就是说(n - 1) & hash
==hash % n
的前提是 n 是 2 的幂次方,但前者 ((n - 1) & hash
) 的效率要比后者 (hash % n
) 高 -
同时,HashMap 的初始容量之所以为 2 的幂次方以及以 2 倍的形式扩容,也是因为
(n - 1) & hash
运算的缘故,按位与 (&) 是位运算,计算机可以直接执行,效率高效,当 HashMap 的容量为 2 的幂次方时,其 (n - 1) 的 2 进制也就是1111***
的形式,这样与节点的 key 的 hash 值进行 & 操作时,能够充分地散列,使得添加的节点均匀地分布在各个桶中,减少哈希冲突,从而提高查询效率 -
举例说明
-
1、HashMap 容量 (n) 为 16,二进制为
10000
,其 (n - 1) 的二进制为01111
,使用(n - 1) & hash
进行运算,往 HashMap 中添加的 key 为 1 (00001)、3 (00011)、5 (00101)、7 (00111)- 如上所示,通过运算 1、3、5、7 分布在了四个不同的桶中
-
2、HashMap 容量 (n) 为 17,二进制为
10001
,其 (n - 1) 的二进制为10000
,使用(n - 1) & hash
进行运算,往 HashMap 中添加的 key 为 1 (00001)、3 (00011)、5 (00101)、7 (00111)- 如上所示,通过运算 1、3、5、7 全部分配到了一号桶中,产生了严重的哈希冲突
-
-
-
PS:这里我们顺道提一下 Java 的取模操作
-
5 % 3 = 2
、-5 % 3 = -2
-
5 % -3 = 2
、-5 % -3 = -2
-
负数取模,先忽略负号,按照正数取模之后,再对被取模的数进行判断,若是正数,则结果为正;若是负数,则结果为负
-
三、常量解析
-
DEFAULT_INITIAL_CAPACITY
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
-
默认初始容量,值为 16,且容量必须为 2 的幂次方
-
问题:为什么容量必须为 2 的幂次方?
- 当 HashMap 的容量为 2 的幂次方时,可以使得添加的节点均匀地分布在各个桶中,减少哈希冲突,从而提高查询效率
-
-
MAXIMUM_CAPACITY
static final int MAXIMUM_CAPACITY = 1 << 30;
-
最大容量,值为
1 << 30
(即 2 的 30次方),当构造函数传入的容量大于该值时,那么将替换成该值 -
问题:int 类型的数据共 4 个字节 32 位,为什么最大容量是
1 << 30
(即 2 的 30次方),而不是1 << 31
(即 2 的 31 次方) 呢?- 这是因为
1 << 31
操作后,其最高位会为 1,而在二进制中最高位为符号位,因此1 << 31
操作会得到一个负数,且该值已经超出了 int 类型的取值范围,所以最多只能左移 30 位
- 这是因为
-
-
DEFAULT_LOAD_FACTOR
static final float DEFAULT_LOAD_FACTOR = 0.75f;
-
默认加载因子,值为 0.75f
-
问题:为什么默认加载因为是 0.75,而不是 0.7、0.8 等其他数值?
-
首先我们先来看看 HashMap 源码注释中给出的解释
* Ideally, under random hashCodes, the frequency of * nodes in bins follows a Poisson distribution * (http://en.wikipedia.org/wiki/Poisson_distribution) with a * parameter of about 0.5 on average for the default resizing * threshold of 0.75, although with a large variance because of * resizing granularity. Ignoring variance, the expected * occurrences of list size k are (exp(-0.5) * pow(0.5, k) / * factorial(k)). The first values are: * * 0: 0.60653066 * 1: 0.30326533 * 2: 0.07581633 * 3: 0.01263606 * 4: 0.00157952 * 5: 0.00015795 * 6: 0.00001316 * 7: 0.00000094 * 8: 0.00000006 * more: less than 1 in ten million
-
如上所示,翻译过来就是说,在随机哈希码的情况下,节点出现在哈希桶中的频率遵循泊松分布,平均参数为 0.5,同时列举除了桶中元素个数和概率的对照表
-
当桶中元素达到 8 个时,概率已经变的非常小了,也就是说,使用 0.75 作为加载因子时,链表长度超过 8 的概率将小于一千万分之一
-
在容量不变的情况下,加载因子过大,会降低查找效率,但会减小空间开销;加载因子过小,会增大空间开销,但会提升查询效率;加载因子取 0.75 是一个折中的方案,在时间和空间成本之间提供了一个很好的权衡
-
-
-
TREEIFY_THRESHOLD
static final int TREEIFY_THRESHOLD = 8;
-
树化阈值,值为 8,即当链表长度 >= 8 时,会将链表转换为红黑树
-
问题:为什么链表长度 >= 8 时,会将链表转换为红黑树?
-
首先我们先来看看 HashMap 源码注释中给出的解释
* This map usually acts as a binned (bucketed) hash table, but * when bins get too large, they are transformed into bins of * TreeNodes, each structured similarly to those in * java.util.TreeMap ~~~ * Because TreeNodes are about twice the size of regular nodes, we * use them only when bins contain enough nodes to warrant use * (see TREEIFY_THRESHOLD). And when they become too small (due to * removal or resizing) they are converted back to plain bins. In * usages with well-distributed user hashCodes, tree bins are * rarely used.
-
如上所示,翻译过来就是说,只有当桶中数据足够多的时候,普通节点才会转换为树型节点 (树型节点的占用空间是普通节点的 2 倍),而是否足够多就是由 TREEIFY_THRESHOLD 来决定的
-
由泊松分布可知,当哈希值离散性很好的时候,数据均匀地分布在每个桶中,几乎不会有桶中的链表长度达到阈值,红黑树使用到的概率也就非常小 (链表长度超过 8 的概率小于一千万分之一)
-
因此树化阈值为 8,个人理解是根据概率统计来决定的,是一种基于空间和时间的权衡,以获得更好的性能
-
-
-
UNTREEIFY_THRESHOLD
static final int UNTREEIFY_THRESHOLD = 6;
- 去树化阈值,值为 6,当链表长度 <= 6 时,会将红黑树转换为链表
-
MIN_TREEIFY_CAPACITY
static final int MIN_TREEIFY_CAPACITY = 64;
-
可树化的最小容量,值为 64,当 HashMap 容量 < 可树化的最小容量时,优先进行扩容而不是树化
-
可树化的最小容量至少要为 TREEIFY_THRESHOLD 的 4 倍,以避免扩容和树化之间的冲突
-
问题:为什么 HashMap 容量 < 64 时,优先进行扩容而不是树化?
- 当 HashMap 容量 < 64 时,如果允许树化,则在扩容时由红黑树拆分、映射等操作带来的性能消耗要比直接扩容的性能消耗要高
-
四、字段解析
-
table
transient Node<K,V>[] table;
-
哈希桶数组,用于存放节点 Node
-
Node 实现了 Map.Entry 接口,用于存放 hash、key、value、next (Node)
-
-
entrySet
transient Set<Map.Entry<K,V>> entrySet;
- 存储了键值对的 Set 集合
-
size
transient int size;
- 键值对个数
-
modCount
transient int modCount;
- 修改 HashMap 结构的次数
-
threshold
int threshold;
- 扩容阈值,扩容阈值 = 容量 * 加载因子
-
loadFactor
final float loadFactor;
- 加载因子
五、构造方法解析
-
HashMap(int initialCapacity, float loadFactor)
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; // 获取大于或等于初始容量,且最接近的 2 的幂次方 this.threshold = tableSizeFor(initialCapacity); }
-
tableSizeFor(int cap)
-
获取大于等于指定容量,且最接近的 2 的幂次方
static final int tableSizeFor(int cap) { // 以下过程的目的是为了让 n 的二进制的低位全部变为 1 int n = cap - 1; // 将 n 无符号右移 1 位,并将结果与右移前的 n 做或运算,再赋值给 n n |= n >>> 1; // 将 n 无符号右移 2 位,并将结果与右移前的 n 做或运算,再赋值给 n n |= n >>> 2; // 将 n 无符号右移 4 位,并将结果与右移前的 n 做或运算,再赋值给 n n |= n >>> 4; // 将 n 无符号右移 8 位,并将结果与右移前的 n 做或运算,再赋值给 n n |= n >>> 8; // 将 n 无符号右移 16 位,并将结果与右移前的 n 做或运算,再赋值给 n n |= n >>> 16; /* * 如果 n < 0,则取 1 作为容量 * 如果 n >= 0,则取 (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1 的结果作为容量 * * (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1 * 如果 n >= MAXIMUM_CAPACITY,则取 MAXIMUM_CAPACITY 作为容量 * 如果 0 <= n < MAXIMUM_CAPACITY,则取 n + 1 作为容量 */ return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1; }
-
示意图 1 (假设 cap 为 1073741825)
-
示意图 2 (假设 cap 为 62)
-
-
-
HashMap(int initialCapacity)
// 内部调用 HashMap(int initialCapacity, float loadFactor) 构造方法;加载因子默认为 0.75 public HashMap(int initialCapacity) { this(initialCapacity, DEFAULT_LOAD_FACTOR); }
-
HashMap()
// 无参构造,初始容量在实际使用时才初始化,默认为 16;加载因子默认为 0.75 public HashMap() { this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted }
-
HashMap(Map<? extends K, ? extends V> m)
public HashMap(Map<? extends K, ? extends V> m) { this.loadFactor = DEFAULT_LOAD_FACTOR; putMapEntries(m, false); }
-
putMapEntries(Map<? extends K, ? extends V> m, boolean evict)
-
将另一个 Map 中的数据拷贝一份到自身的存储结构中
final void putMapEntries(Map<? extends K, ? extends V> m, boolean evict) { int s = m.size(); if (s > 0) { // 如果数组为 null if (table == null) { /* * 【(float)s / loadFactor + 1.0F】 操作可以得到一个容量, * 则当前需要构造的 HashMap 的初始容量,必须要大于该容量, * 否则会触发扩容 * * 这里的 【+ 1.0F】 操作是为了避免临界情况, * 例如:m 中元素个数 s 为 24,除以 0.75 得到的容量为 32, * 调用 tableSizeFor(32) 方法得到的结果也为 32,但此时 * 元素个数为 24,已经达到了扩容阈值,因此我们期望 tableSizeFor() * 方法返回的应该是 64,两者相矛盾,所以要【+ 1.0F】, * 这样调用 tableSizeFor(33) 方法返回 64 就符合预期了 */ float ft = ((float)s / loadFactor) + 1.0F; int t = ((ft < (float)MAXIMUM_CAPACITY) ? (int)ft : MAXIMUM_CAPACITY); /* * 如果计算得到的容量 t 大于扩容阈值 * (此处扩容阈值还未进行初始化,值为 0) * 则获取大于 t,且最接近的 2 的幂次方, * 将其赋值给扩容阈值 */ if (t > threshold) threshold = tableSizeFor(t); } // 如果 m 中元素个数大于扩容阈值,则进行扩容 else if (s > threshold) resize(); // 遍历 m 中所有元素,将它们添加到自身的存储结构中 for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) { K key = e.getKey(); V value = e.getValue(); putVal(hash(key), key, value, false, evict); } } }
-
-
六、方法解析
1、计算哈希值
-
hash(Object key)
static final int hash(Object key) { int h; return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16); }
-
计算 key 的哈希值,该哈希值会参与数组下标的计算 (
(n - 1) & hash
) -
问题:为什么不直接使用 key 原有的哈希值,而要使用
(h = key.hashCode()) ^ (h >>> 16)
操作得到的值?-
1、使用 key 原有的哈希值参与数组下标的计算 (
(n - 1) & hash
) (假设 key 为 78897121、n 为 16)- 如上所示,在计算数组下标时 (
(n - 1) & hash
),由于 n 较小,其高 28 位都为 0,而与 0 进行 & 操作必然为 0,所以哈希值的高 28 位就没有任何作用了,始终只有其低 4 位参与了运算,哈希冲突的概率也会增加
- 如上所示,在计算数组下标时 (
-
2、使用计算后的哈希值参与数组下标的计算 (
(n - 1) & hash
) (假设 key 为 78897121、n 为 16)- 鉴于此,我们可以通过
(h = key.hashCode()) ^ (h >>> 16)
操作让哈希值的高 16 位与低 16 位进行异或 (^) 操作,变相地让高位数据参与到计算中,增大哈希值低位数值的随机性,从而让计算得到数组下标更加散列
- 鉴于此,我们可以通过
-
-
2、查找
-
get(Object key)
public V get(Object key) { Node<K,V> e; // 获取节点,如果节点为空则返回 null,不为空则返回 value return (e = getNode(hash(key), key)) == null ? null : e.value; }
- 根据 key 获取 value
-
getNode(int hash, Object key)
final Node<K,V> getNode(int hash, Object key) { Node<K,V>[] tab; Node<K,V> first, e; int n; K k; /* * 1、(tab = table) != null * 判断数组是否不为 null * 2、(n = tab.length) > 0 * 判断数组长度是否大于 0 * 3、(first = tab[(n - 1) & hash]) != null * 根据 (n - 1) & hash 计算对应的数组下标, * 并判断该下标处存储的节点是否不为 null */ if ((tab = table) != null && (n = tab.length) > 0 && (first = tab[(n - 1) & hash]) != null) { /* * 1、first.hash == hash * 判断头部节点的 hash 值与参数 key 的 hash 值是否相等 * 2、(k = first.key) == key || (key != null && key.equals(k)) * 1、(k = first.key) == key * 将头部节点的 key 与参数 key 做比较,如果 key 是基本数据类型, * 则比较两者值是否相等;如果是引用数据类型,则比较两者地址是否相等 * 2、key != null && key.equals(k) * 在参数 key 不为 null 的情况下,判断参数 key 的值与头部节点的 key 的值是否相等 */ if (first.hash == hash && // always check first node ((k = first.key) == key || (key != null && key.equals(k)))) // 满足上述条件时,返回头部节点 return first; // 如果头部节点的后继节点不为 null 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; }
-
根据 hash 和 key 获取节点
-
getNode 方法流程归纳
-
1、计算 key 对应的数组下标,并判断该下标处的头部节点是否为所要找的节点,如果是,则返回
-
2、如果不是,则再判断该头部节点是否为树型节点,如果是,则调用红黑树的查找方法,如果不是,则遍历链表进行查找
-
-
-
containsKey(Object key)
public boolean containsKey(Object key) { // 获取节点,如果节点不为空则返回 true,为空则返回 false return getNode(hash(key), key) != null; }
- 判断是否包含指定的 key
-
containsValue(Object value)
public boolean containsValue(Object value) { Node<K,V>[] tab; V v; // 如果数组不为 null 且数组长度大于 0 if ((tab = table) != null && size > 0) { // 遍历数组 for (int i = 0; i < tab.length; ++i) { // 遍历链表 for (Node<K,V> e = tab[i]; e != null; e = e.next) { // 如果 value 的值相等或地址相等,则返回 true if ((v = e.value) == value || (value != null && value.equals(v))) return true; } } } return false; }
- 判断是否包含指定的 value
3、添加
-
put(K key, V value)
public V put(K key, V value) { return putVal(hash(key), key, value, false, true); }
-
添加 key、value 键值对
-
如果 key 未重复,添加成功时返回 null;如果 key 重复,添加成功时返回 key 对应的上一个 value 值
-
举例说明
Map<Integer, Integer> map = new HashMap<>(1); map.put(1, 11); Integer value = map.put(1, 22); System.out.println(value); // 11
-
-
putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict)
final V putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict) { Node<K,V>[] tab; Node<K,V> p; int n, i; /* * 1、(tab = table) == null * 判断数组是否为 null * 2、n = tab.length) == 0 * 判断数组长度是否为 0 */ if ((tab = table) == null || (n = tab.length) == 0) // 调用 resize() 方法初始化数组容量,并将其赋值给 n n = (tab = resize()).length; /* * 计算 key 对应的数组下标, * 如果该下标处的头部节点为 null, * 则创建一个新节点,将其存放至该下标处 */ if ((p = tab[i = (n - 1) & hash]) == null) tab[i] = newNode(hash, key, value, null); // 如果头部节点不为 null else { Node<K,V> e; K k; // 如果头部节点是所要找的节点,则将 e 节点的引用指向 p 节点 if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) e = p; // 如果头部节点是树型节点,则调用红黑树的添加方法 else if (p instanceof TreeNode) e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value); // 如果都不是,则将新节点添加至链表的最后,或者是更新键值对 else { // 对链表进行遍历,并统计链表长度 for (int binCount = 0; ; ++binCount) { /* * 如果头部节点不存在后继节点, * 则创建一个新节点,将 p 节点的 next 的引用指向新节点 */ if ((e = p.next) == null) { p.next = newNode(hash, key, value, null); // 如果链表长度大于等于树化阈值,则进行树化操作 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 节点的引用指向当前节点 p = e; } } // 如果要插入的节点不为 null if (e != null) { // existing mapping for key // 取该节点的旧 value V oldValue = e.value; /* * 当 onlyIfAbsent 参数为 false 或者 * 旧 value 为 null,使用新 value 覆盖旧 value */ if (!onlyIfAbsent || oldValue == null) e.value = value; // 供 LinkedHashMap 进行回调处理 afterNodeAccess(e); // 返回旧 value return oldValue; } } ++modCount; // 如果数组容量大于扩容阈值,则进行扩容 if (++size > threshold) resize(); // 供 LinkedHashMap 进行回调处理 afterNodeInsertion(evict); return null; }
-
添加节点
-
这里有两个参数需要说明一下
参数 作用 onlyIfAbsent 如果为 true,则不改变当前的值,意思就是当 key 相同时,不用新值去替换旧值
在使用putIfAbsent(K key, V value)
方法时,该参数为 true,其他使用地方都为 falseevict 如果为 false,则表示哈希表处于创建模式
该参数在afterNodeInsertion(boolean evict)
方法中被使用,
该方法主要用于 LinkedHashMap 进行回调处理 -
putVal 方法流程归纳
-
1、如果数组尚未初始化,则调用
resize()
方法对其进行初始化 -
2、计算 key 对应的数组下标,并判断该下标处的头部节点是否已存在,如果不存在,则添加新节点
-
3、如果存在,则再判断待添加的节点是否为树型节点,如果是,则调用红黑树的添加方法
-
4、如果不是,则在链表上添加该节点,并根据链表长度决定是否转换为红黑树
-
5、最后判断数组容量是否大于扩容阈值,如果大于则进行扩容
-
-
4、删除
-
remove(Object key)
public V remove(Object key) { Node<K,V> e; return (e = removeNode(hash(key), key, null, false, true)) == null ? null : e.value; }
-
根据 key 删除键值对
-
如果删除成功,则返回被删除的 key 对应的 value 值;如果失败,则返回 null
-
举例说明
public static void main(String[] args) { Map<Integer, Integer> map = new HashMap<>(1); map.put(1, 11); map.put(2, 22); Integer value = map.remove(1); System.out.println(value); // 11 }
-
-
remove(Object key, Object value)
public boolean remove(Object key, Object value) { return removeNode(hash(key), key, value, true, true) != null; }
-
根据 key、value 删除键值对
-
如果删除成功,则返回 true;如果失败,则返回 false
-
举例说明
public static void main(String[] args) { Map<Integer, Integer> map = new HashMap<>(1); map.put(1, 11); map.put(2, 22); boolean value = map.remove(1, 11); System.out.println(value); // true }
-
-
removeNode(int hash, Object key, Object value, boolean matchValue, boolean movable)
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; /* * 1、(tab = table) != null * 判断数组是否不为 null * 2、(n = tab.length) > 0 * 判断数组长度是否大于 0 * 3、(first = tab[(n - 1) & hash]) != null * 根据 (n - 1) & hash 计算对应的数组下标, * 并判断该下标处存储的节点是否不为 null */ 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 节点的引用指向 p 节点 if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) node = p; // 如果头部节点的后继节点不为 null 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; // 供 LinkedHashMap 进行回调处理 afterNodeRemoval(node); return node; } } return null; }
-
删除节点
-
这里有两个参数需要说明一下
参数 作用 matchValue 如果为 true,则表示当 key、value 都相同时,才进行删除 movable 如果为 false,则表示在删除时不要移动其他节点
在红黑树的删除方法中会使用到该参数 -
removeNode 方法流程归纳
-
1、计算 key 对应的数组下标,并判断该下标处的头部节点是否为待删除的节点,如果是,则删除,并将其后继节点置为新的头部节点
-
2、如果不是,则再判断待删除的节点是否为树型节点,如果是,则调用红黑树的删除方法
-
3、如果不是,则在链表上删除该节点,并将待删除节点的前驱节点的引用指向待删除节点的后继节点
-
-
5、遍历
-
keySet()
public Set<K> keySet() { Set<K> ks = keySet; if (ks == null) { ks = new KeySet(); keySet = ks; } return ks; }
-
获取 key 的集合
-
举例说明
public static void main(String[] args) { Map<Integer, Integer> map = new HashMap<>(); map.put(3, 333); map.put(2, 222); map.put(1, 111); map.keySet().forEach(key -> System.out.print(key + "=" + map.get(key) + " ")); // 1=111 2=222 3=333 } public static void main(String[] args) { Map<Integer, Integer> map = new HashMap<>(); map.put(3, 333); map.put(2, 222); map.put(1, 111); Iterator<Integer> iterator = map.keySet().iterator(); while (iterator.hasNext()) { Integer key = iterator.next(); System.out.print(key + "=" + map.get(key) + " "); } } // 1=111 2=222 3=333
-
-
values()
public Collection<V> values() { Collection<V> vs = values; if (vs == null) { vs = new Values(); values = vs; } return vs; }
-
获取 value 的集合
-
举例说明
public static void main(String[] args) { Map<Integer, Integer> map = new HashMap<>(); map.put(3, 333); map.put(2, 222); map.put(1, 111); map.values().forEach(value -> System.out.print(value + " ")); // 111 222 333 }
-
-
entrySet()
public Set<Map.Entry<K,V>> entrySet() { Set<Map.Entry<K,V>> es; return (es = entrySet) == null ? (entrySet = new EntrySet()) : es; }
-
获取切面的集合
-
举例说明
public static void main(String[] args) { Map<Integer, Integer> map = new HashMap<>(); map.put(3, 333); map.put(2, 222); map.put(1, 111); map.entrySet().forEach(entry -> System.out.print(entry.getKey() + "=" + entry.getValue() + " ")); // 1=111 2=222 3=333 }
-
-
通过上面三种遍历我们可以发现,遍历结果的顺序与插入的顺序不一致,这是为什么呢?让我们来一起看看遍历的源码,这里用 keySet() 来举例说明
-
使用
forEach()
方法// KeySet public final void forEach(Consumer<? super K> action) { Node<K,V>[] tab; if (action == null) throw new NullPointerException(); if (size > 0 && (tab = table) != null) { int mc = modCount; // 循环数组 for (int i = 0; i < tab.length; ++i) { // 循环链表 for (Node<K,V> e = tab[i]; e != null; e = e.next) action.accept(e.key); } if (modCount != mc) throw new ConcurrentModificationException(); } }
-
使用
iterator()
迭代器// KeySet public final Iterator<K> iterator() { return new KeyIterator(); } // KeyIterator final class KeyIterator extends HashIterator implements Iterator<K> { public final K next() { return nextNode().key; } } // HashIterator final Node<K,V> nextNode() { Node<K,V>[] t; Node<K,V> e = next; if (modCount != expectedModCount) throw new ConcurrentModificationException(); if (e == null) throw new NoSuchElementException(); // 如果当前桶中链表已遍历完,则开始寻找下一个包含有链表的桶 if ((next = (current = e).next) == null && (t = table) != null) { do {} while (index < t.length && (next = t[index++]) == null); } return e; }
-
由两种循环的源码可知,HashMap 在循环时,会先遍历桶数组,找到包含链表的桶,对链表进行遍历,遍历完后,再寻找下一个包含链表的桶,如此反复
-
-
循环示例
public static void main(String[] args) { Map<Integer, Integer> map = new HashMap<>(); map.put(20, 20); map.put(4, 4); map.put(36, 36); map.put(32, 32); map.put(16, 16); map.put(0, 0); map.put(2, 2); map.put(34, 34); map.put(18, 18); Iterator<Integer> iterator = map.keySet().iterator(); int i = 0; while (iterator.hasNext()){ if (i == 0) { System.out.print(iterator.next()); } else { System.out.print(" -> " + iterator.next()); } i++; } }
- 如上所示,最终输出结果为:32 -> 16 -> 0 -> 2 -> 34 -> 18 -> 20 -> 4 -> 36
6、扩容
-
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; // 如果原容量大于 0,说明数组已被初始化且存有数据 if (oldCap > 0) { // 如果旧容量大于等于最大容量,则将新扩容阈值设置为 Integer.MAX_VALUE,并返回旧数组 if (oldCap >= MAXIMUM_CAPACITY) { threshold = Integer.MAX_VALUE; return oldTab; } /* * 将新容量设置为旧容量的 2 倍 * 如果新容量小于最大容量并且旧容量大于等于默认初始容量 (16) * 则将新扩容阈值设置为旧扩容阈值的 2 倍 */ else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY) newThr = oldThr << 1; // double threshold } /* * 如果原容量小于等于 0, * 则表示数组未被初始化,且没有存放数据 * 当调用 put() 方法往 HashMap 中添加数据时, * 会调用 resize() 方法来初始化容量 * * 在此种情况下,如果旧扩容阈值大于 0,则表示调用了 * HashMap 带有初始容量 (initialCapacity) 的构造函数(有两个), * 这两个构造函数在初始化时,会调用 tableSizeFor(initialCapacity) 方法 * 来获取大于等于初始容量,且最接近的 2 的幂次方,然后将其赋值给 threshold * * 举例 * initialCapacity 为 11,调用 tableSizeFor(initialCapacity) 方法 * 后得到 16,将其赋值给 threshold,而 threshold 又被赋值给了 oldThr * 因此 oldThr 也为 16 * * 此处判断为 true 后,将 oldThr 的值赋值给新容量,作为初始容量 */ else if (oldThr > 0) // initial capacity was placed in threshold newCap = oldThr; /* * 以上条件都不满足时,在此种情况下, * 表示调用了 HashMap 的无参构造函数 * * 将新容量设置为默认初始容量 (16) * 将新扩容阈值设置为默认初始容量 * 默认加载因子(16 * 0.75 = 12) */ else { // zero initial threshold signifies using defaults newCap = DEFAULT_INITIAL_CAPACITY; newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); } /* * 如果走的是上面的第二个分支, * 则新扩容阈值仍未 0,因此按公式计算新扩容阈值 */ if (newThr == 0) { float ft = (float)newCap * loadFactor; newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ? (int)ft : Integer.MAX_VALUE); } // 将计算出来的新扩容阈值赋值给 threshold threshold = newThr; @SuppressWarnings({"rawtypes","unchecked"}) // 创建一个新数组用于存放原数组中的元素 Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap]; // 将 table 的引用指向新数组 table = newTab; // 如果旧数组不为 null,则遍历旧数组,将旧数组中的节点添加至新数组 if (oldTab != null) { for (int j = 0; j < oldCap; ++j) { // 桶中头部节点 Node<K,V> e; // 若原数组对应 j 下标处有节点存在,则进行下一步操作 if ((e = oldTab[j]) != null) { // oldTab[j] 的值或引用已经赋值给了 e,因此将其设置为 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 Node<K,V> loHead = null, loTail = null; Node<K,V> hiHead = null, hiTail = null; Node<K,V> next; do { next = e.next; if ((e.hash & oldCap) == 0) { if (loTail == null) loHead = e; else loTail.next = e; loTail = e; } else { if (hiTail == null) hiHead = e; else hiTail.next = e; hiTail = e; } } while ((e = next) != null); if (loTail != null) { loTail.next = null; newTab[j] = loHead; } if (hiTail != null) { hiTail.next = null; newTab[j + oldCap] = hiHead; } } } } } return newTab; }
-
初始化或扩容数组容量
-
当对数组进行扩容时,如果存在链表,则需要对链表进行拆分处理
-
首先我们抛出一个结论:旧数组中一条链表上的所有节点,在加入新数组后,最多会分布在新数组的两条链表上
-
至于为什么,让我们一起来看看下面的示意图 (假设旧数组长度为 8,新数组长度为 16)
-
看完示意图后,想必大家都清楚了链表扩容的机制,现在让我们再来看看源码,就轻松多了
// 创建两个首尾节点,表示一条下标不变的链表 (保持节点之间的原有顺序) Node<K,V> loHead = null, loTail = null; // 创建两个首尾节点,表示一条 (下标 + oldCap) 的链表 (保持节点之间的原有顺序) Node<K,V> hiHead = null, hiTail = null; Node<K,V> next; // 循环遍历链表 do { // 将 next 节点的引用指向当前节点的后继节点 next = e.next; /* * 使用当前节点的 hash 值与旧数组容量进行 & 运算 * 如果等于 0,则放入下标不变的链表中 */ if ((e.hash & oldCap) == 0) { /* * 若这是下标不变的链表的第一个节点, * 则将 loHead 节点的引用指向当前节点 */ if (loTail == null) loHead = e; // 若不是,则将 loTail 节点的 next 的引用指向当前节点 else loTail.next = e; // 更新尾部引用,将 loTail 节点的引用指向当前节点 loTail = e; } /* * 如果 & 运算不为 0, * 则放入 (下标 + oldCap) 的链表中 */ else { /* * 若这是 (下标 + oldCap) 的链表的第一个节点, * 则将 hiHead 节点的引用指向当前节点 */ if (hiTail == null) hiHead = e; // 若不是,则将 hiTail 节点的 next 的引用指向当前节点 else hiTail.next = e; // 更新尾部引用,将 hiTail 节点的引用指向当前节点 hiTail = e; } } while ((e = next) != null); /* * 当遍历完所有节点, * 判断下标不变的链表中是否有节点存在 */ if (loTail != null) { // 将 loTail 节点的 next 引用设置为 null loTail.next = null; // 将 loHead 节点放入新数组对应 j 下标处 newTab[j] = loHead; } /* * 当遍历完所有节点, * 判断 (下标 + oldCap) 的链表中是否有节点存在 */ if (hiTail != null) { // 将 hiTail 节点的 next 引用设置为 null hiTail.next = null; // 将 hiHead 节点放入新数组对应 (j + oldCap) 下标处 newTab[j + oldCap] = hiHead; }
-
-
resize 方法流程归纳
-
1、计算新数组的容量 (newCap) 和扩容阈值 (newThr)
-
2、根据 newCap 创建新数组,并进行初始化
-
3、遍历旧数组,将旧数组中的节点按顺序映射到新数组中
-
-
7、红黑树与链表转换
-
treeifyBin(Node<K,V>[] tab, int hash)
final void treeifyBin(Node<K,V>[] tab, int hash) { int n, index; Node<K,V> e; // 当哈希桶数组为 null 或容量小于最小树化阈值时,优先进行扩容而不是树化 if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY) resize(); // 如果哈希桶的头部节点不为 null,则将普通链表转换为树型节点链表 else if ((e = tab[index = (n - 1) & hash]) != null) { // 声明一个树型头节点和一个树型尾节点 TreeNode<K,V> hd = null, tl = null; do { // 将普通节点转换为树型节点 TreeNode<K,V> p = replacementTreeNode(e, null); /* * 若这是树型节点链表的第一个节点, * 则将 hd 节点的引用指向当前树型节点 */ if (tl == null) hd = p; /* * 若不是,则将当前树型节点的 prev 的引用指向 tl 节点, * 将 tl 节点的 next 的引用指向当前树型节点 * * 即将当前树型节点连接至树型节点链表的尾部 */ else { p.prev = tl; tl.next = p; } // 更新尾部引用,将 tl 节点的引用指向当前树型节点 tl = p; } while ((e = e.next) != null); /* * 循环结束,将树型头节点放入对应 index 位置的哈希桶中 * 并判断是否不为 null,如果不为 null,则将树型节点链表转换为红黑树 */ 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); }
-
将普通链表转换为由树型节点组成的链表,然后转换成红黑树
-
链表树化条件
-
链表长度大于等于树化阈值 (TREEIFY_THRESHOLD)
-
数组容量大于等于可树化的最小容量 (MIN_TREEIFY_CAPACITY)
-
可树化的最小容量 (MIN_TREEIFY_CAPACITY) 至少要为树化阈值 (TREEIFY_THRESHOLD) 的 4 倍,以避免扩容和树化之间的冲突
-
-
treeifyBin 方法流程归纳
-
1、判断哈希桶数组容量是否小于可树化的最小容量,如果小于则进行扩容
-
2、如果大于,则将哈希桶中的普通链表转换为树型节点链表
-
3、将树型节点链表的头节点放入哈希桶中,并将树型节点链表转换为红黑树
-
-
-
treeify(Node<K,V>[] tab)
static final int TREEIFY_THRESHOLD = 8; static final int MIN_TREEIFY_CAPACITY = 64; final void treeify(Node<K,V>[] tab) { // 红黑树根节点 TreeNode<K,V> root = null; // 循环树型节点链表 for (TreeNode<K,V> x = this, next; x != null; x = next) { // 将 next 节点的引用指向当前树型节点的后继节点 next = (TreeNode<K,V>)x.next; // 将当前树型节点的左右节点都设置为 null x.left = x.right = null; // 如果当前红黑树不存在根节点 if (root == null) { // 设置当前树型节点的父节点为 null x.parent = null; // 设置当前树型节点的颜色为黑色 (红黑树根节点为黑色) x.red = false; // 将当前树型节点设置为红黑数的根节点 root = x; } // 如果当前红黑树存在根节点 else { // 取当前树型节点的 key K k = x.key; // 取当前树型节点的 hash int h = x.hash; // 声明一个 Class 变量 (kc,key 的 Class) Class<?> kc = null; // 从红黑树的根节点进行遍历,将当前树型节点插入到红黑树中 for (TreeNode<K,V> p = root;;) { /* * dir:方向 * ph:当前红黑树节点 hash */ int dir, ph; // 取当前红黑树节点的 key K pk = p.key; /* * 如果当前红黑树节点的 hash 大于当前树型节点的 hash * 则标识当前树型节点会被放到当前红黑树节点的左侧 */ if ((ph = p.hash) > h) // -1:表示左侧 dir = -1; /* * 如果当前红黑树节点的 hash 小于当前树型节点的 hash * 则标识当前树型节点会被放到当前红黑树节点的右侧 */ else if (ph < h) // 1:表示右侧 dir = 1; /* * 如果以上两个分支都没走,则表示两个节点的 hash 相等, * 需要通过进一步的方式来进行比较 * * 如果当前树型节点的 key 实现了 Comparable 接口, * 则调用 compareTo() 方法对两个节点的 key 进行比较 * 如果 compareTo() 结果为 0,则调用 tieBreakOrder() * 方法继续进行比较 */ else if ((kc == null && (kc = comparableClassFor(k)) == null) || (dir = compareComparables(kc, k, pk)) == 0) dir = tieBreakOrder(k, pk); // 缓存当前红黑树节点,即将 xp 节点的引用指向当前红黑树节点 TreeNode<K,V> xp = p; /* * 如果左子树或右子树为 null * (根据 dir 的大小来判断是在左侧插入还是在右侧插入) */ if ((p = (dir <= 0) ? p.left : p.right) == null) { // 将之前缓存的当前红黑树节点 (此时为 px 节点) 设置为当前树型节点的父节点 x.parent = xp; // 如果 dir 小于等于 0,则将当前树型节点插入 px 节点的左侧 if (dir <= 0) xp.left = x; // 如果 dir 大于 0,则将当前树型节点插入 px 节点的右侧 else xp.right = x; // 调用 balanceInsertion() 方法进行插入平衡 root = balanceInsertion(root, x); break; } } } } // 确保哈希桶中存储的头部节点是红黑树的根节点 moveRootToFront(tab, root); }
- 将树型节点链表转换为红黑树
-
split(HashMap<K,V> map, Node<K,V>[] tab, int index, int bit)
final void split(HashMap<K,V> map, Node<K,V>[] tab, int index, int bit) { TreeNode<K,V> b = this; // 创建两个首尾树型节点,表示一条下标不变的树型链表 (保持节点之间的原有顺序) TreeNode<K,V> loHead = null, loTail = null; // 创建两个首尾树型节点,表示一条 (下标 + oldCap) 的树型链表 (保持节点之间的原有顺序) TreeNode<K,V> hiHead = null, hiTail = null; /* * lc:记录下标不变的树型链表的长度 * hc:记录 (下标 + oldCap) 的树型链表的长度 */ int lc = 0, hc = 0; // 遍历循环链表 for (TreeNode<K,V> e = b, next; e != null; e = next) { // 将 next 节点的引用指向当前节点的后继节点 next = (TreeNode<K,V>)e.next; // 将当前节点的 next 的引用设置为 null e.next = null; /* * 此处 bit 即 oldCap * 使用当前节点的 hash 值与旧数组容量进行 & 运算 * 如果等于 0,则放入下标不变的树型链表中 */ if ((e.hash & bit) == 0) { /* * 若这是下标不变的树型链表的第一个节点, * 则将 loHead 节点的引用指向当前节点 */ if ((e.prev = loTail) == null) loHead = e; // 若不是,则将 loTail 节点的 next 的引用指向当前节点 else loTail.next = e; // 更新尾部引用,将 loTail 节点的引用指向当前节点 loTail = e; ++lc; } /* * 如果 & 运算不为 0, * 则放入 (下标 + oldCap) 的树型链表中 */ else { /* * 若这是 (下标 + oldCap) 的树型链表的第一个节点, * 则将 hiHead 节点的引用指向当前节点 */ if ((e.prev = hiTail) == null) hiHead = e; // 若不是,则将 hiTail 节点的 next 的引用指向当前节点 else hiTail.next = e; // 更新尾部引用,将 hiTail 节点的引用指向当前节点 hiTail = e; ++hc; } } /* * 当所有树型节点遍历完后, * 判断下标不变的树型链表中是否有树型节点存在 */ if (loHead != null) { /* * 如果长度小于等于去树化阈值, * 则将该树型链表转换为普通链表 */ if (lc <= UNTREEIFY_THRESHOLD) tab[index] = loHead.untreeify(map); // 如果长度大于去树化阈值 else { // 将 loHead 节点放入数组对应 index 下标处 tab[index] = loHead; /* * 如果另一条树型链表上有树型节点存在, * 则将该树型链表进行树化操作 * * 如果另一条树型链表上没有树型节点存在, * 则表示所有树型节点都在该树型链表上, * 树结构不变,无需重新树化 */ if (hiHead != null) // (else is already treeified) loHead.treeify(tab); } } /* * 当所有树型节点遍历完后, * 判断 (下标 + oldCap) 的树型链表中是否有树型节点存在 */ if (hiHead != null) { /* * 如果长度小于等于去树化阈值, * 则将该树型链表转换为普通链表 */ if (hc <= UNTREEIFY_THRESHOLD) tab[index + bit] = hiHead.untreeify(map); // 如果长度大于去树化阈值 else { // 将 hiHead 节点放入数组对应 (index + bit) 下标处 tab[index + bit] = hiHead; /* * 如果另一条树型链表上有树型节点存在, * 则将该树型链表进行树化操作 * * 如果另一条树型链表上没有树型节点存在, * 则表示所有树型节点都在该树型链表上, * 树结构不变,无需重新树化 */ if (loHead != null) hiHead.treeify(tab); } } }
- 拆分红黑树,在哈希桶数组进行扩容时,将红黑树拆分成两棵树,在红黑树太小时进行去树化操作
-
untreeify(HashMap<K,V> map)
static final int UNTREEIFY_THRESHOLD = 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); /* * 如果 p 节点是链表的第一个节点, * 则将 hd 节点的引用指向 p 节点 */ if (tl == null) hd = p; // 若不是,则将 tl 节点的 next 的引用指向 P 节点 else tl.next = p; // 更新尾部引用,将 tl 节点的引用指向 p 节点 tl = p; } // 返回链表的头部节点 return hd; } Node<K,V> replacementNode(Node<K,V> p, Node<K,V> next) { return new Node<>(p.hash, p.key, p.value, next); }
-
将红黑树 (树型节点链表) 转换为普通链表
-
由于在链表转换为红黑树时,保留链表原有的节点顺序,因此在红黑树转换为链表时就方便多了,只需要将树型节点列表转换为普通节点列表即可
-
七、序列化解析
1、简述
-
HashMap 实现了 Serializable 接口,则意味着 HashMap 可以被序列化,在 Java 中,提供了 ObjectOutputStream 和 ObjectInputStream 两个类来对对象进行序列化和反序列化
-
但在源码中我们会发现,有四个变量使用了 transient 关键字进行修饰,也就是说这四个变量不会参与到序列化中,可是我们序列化与反序列化需要的就是 table 中存储的键值对数据,这不就前后矛盾了吗?
-
在这里我们先抛出个结论,HashMap 在序列化和反序列的过程中会调用自身重写的 writeObject 和 readObject 方法来完成操作,不会调用 Java 默认的序列化和反序列化方法
transient Node<K,V>[] table; transient Set<Map.Entry<K,V>> entrySet; transient int size; transient int modCount;
2、举例
-
我们先来举个 HashMap 序列化与反序列化的例子
public class HashMapTest { private static void serialize(Map<Integer, String> map, String path) { ObjectOutputStream oos = null; try (FileOutputStream fos = new FileOutputStream(path)) { oos = new ObjectOutputStream(fos); oos.writeObject(map); } catch (IOException e) { e.printStackTrace(); } finally { if (oos != null) { try { oos.close(); } catch (IOException e) { e.printStackTrace(); } } } } private static Map<Integer, String> deserialize(String path) { ObjectInputStream ois = null; Map<Integer, String> map = null; try (FileInputStream fis = new FileInputStream(path)) { ois = new ObjectInputStream(fis); map = (Map<Integer, String>) ois.readObject(); } catch (IOException | ClassNotFoundException e) { e.printStackTrace(); } finally { if (ois != null) { try { ois.close(); } catch (Exception e) { e.printStackTrace(); } } } return map; } public static void main(String[] args) { String path = "C:\\Users\\XJ\\Desktop\\HashMap.txt"; Map<Integer, String> map = new HashMap<>(); map.put(1, "AAA"); map.put(2, "BBB"); map.put(3, "CCC"); serialize(map, path); Map<Integer, String> deserialize = deserialize(path); if (deserialize != null) { deserialize.forEach((key, value) -> System.out.println(key + " = " + value)); } // 1 = AAA // 2 = BBB // 3 = CCC } }
- 如上所示,我们定义了一个
serialize(Map<Integer, String> map, String path)
序列化方法和一个deserialize(String path)
反序列化方法,接着将 HashMap 序列化到本地文件,然后再将文件反序列化,并输出内容
- 如上所示,我们定义了一个
3、Debug 追踪
-
有了上面的例子后,就方便我们查看源码了,我们使用 Debug 模式来启动 main() 方法,然后一路 Debug,最终会来到一个名为 writeSerialData 的方法
- 如上所示,当 ObjectOutputStream 在序列化过程中,会判断被序列化的对象是否重写了 writeObject 方法,如果重写了,则会调用被序列化对象自身的 writeObject 方法,如果没有,则会调用默认的序列化方法
-
要是上面的流程不是清楚的话,我们再来看看 writeSerialData 方法的层级调用树 (Navigate --> Call Hierarchy)
-
至此,HashMap 的整个序列化过程就一目了然了,至于反序列化,也是相同的道理,最终会定位到一个名为 readSerialData 的方法,即当 ObjectInputStream 在反序列化过程中,会判断被反序列化的对象是否重写了 readObject 方法,如果重写了,则会调用被反序列化对象自身的 readObject 方法;如果没有,则会调用默认的反序列化方法,至于反序列化的源码,此处就不再展示了
4、问题:为什么 HashMap 要自己实现 writeObject 和 readObject 方法?
-
在 HashMap 中,各个节点存放于哪个哈希桶中是根据节点 key 的 hash 值来决定的,然后对于同一个 key,在不同的 JVM 实现中计算得到 hash 值可能是不同的,也就是说,同一个 HashMap 对象在反序列化之后的结果和序列化之前的结果是不一样的,这就会导致使用同一个 key 会得到不同的值
-
因此 HashMap 采取了以下措施来解决这个问题
-
1、对可能会导致数据不一致的元素使用 transient 关键字进行修饰,涉及到的字段有:table、entrySet、size、modCount
-
2、自行实现序列化 (writeObject) 和反序化 (readObject) 方法,保证了序列化和反序列化结果的一致性
-
八、HashMap 和 Hashtable 的区别
-
继承的父类不同
-
HashMap:继承自 AbstractMap 类
-
Hashtable:继承自 Dictionary 类
-
-
线程安全性不同
-
HashMap:线程不安全,但性能较好
-
Hashtable:线程安全,但性能较差
-
-
对于 null 的处理不同
-
HashMap:key 和 value 都可以存放 null,但 key 只能存在一个 null,value 可以存在一个或多个 null
-
Hashtable:key 和 value 都不可以存放 null,一旦存放 null,会报空指针异常
-
-
初始容量不同
-
HashMap:默认初始容量为 16
-
Hashtable:默认初始容量为 11
-
-
扩容方式不同
-
HashMap:新容量 = 原容量 * 2
-
Hashtable:新容量 = 原容量 * 2 + 1
-
-
出现的版本不同
-
HashMap:出现在 JDK2 中
-
Hashtable:出现在 JDK1 中
-
九、归纳总结
-
哈希表
- 哈希表,也称散列表,是根据关键码值而直接访问的数据结构,它通过把关键码值映射到表中一个位置来访问记录,以加快查询的速度,这个映射函数叫做哈希 (散列) 函数,存放记录的数据叫做哈希 (散列) 表
-
哈希冲突
- 哈希冲突,也称哈希碰撞,对不同的关键字使用哈希函数进行计算,可能会得到相同的散列地址,这种现象称为哈希冲突
-
哈希冲突的解决方法
-
开放地址法
-
再散列法
-
链地址法 (拉链法,即数据 + 链表的方式)
-
-
为什么 HashMap 的容量是 2 的幂次方?
-
HashMap 通过
(n - 1) & hash
运算来计算数组下标,(n - 1) & hash
运算等价于hash % n
,即在取模操作中,如果除数是 2 的幂次方,则等价于与其除数减一的 & 操作,也就是说(n - 1) & hash
==hash % n
的前提是 n 为 2 的幂次方,但前者的效率 ((n - 1) & hash
) 要比后者 (hash % n
) 高 -
当 HashMap 的容量是 2 的幂次方时,使用
(n - 1) & hash
运算来计算数组下标,可以使得添加的节点均匀地分布在各个桶中,减少哈希冲突,从而提高查询效率
-
-
为什么 HashMap 默认加载因子为 0.75?
-
根据源码注释可知,节点出现在哈希桶中的频率遵循泊松分布,当桶中元素达到 8 个时,概率已经变的非常小了,也就是说,使用 0.75 作为加载因子时,链表长度超过 8 的概率将小于一千万分之一
-
在容量不变的情况下,加载因子过大,会降低查询效率,但会减小空间开销;加载因子过小,会增大空间开销,但会提升查询效率;加载因子取 0.75 是一个折中的方案,在时间和空间的成本之间提供了一个很好的权衡
-
-
为什么 HashMap 要自己实现 writeObject 和 readObject 方法?
-
对于同一个节点 key,在不同的 JVM 实现中计算得到的 hash 值可能是不同的,也就是说,对于同一个 HashMap 对象而言,序列化和反序列化的结果是不一致的,这就会导致使用同一个 key 会得到不同的值
-
因此 HashMap 自行实现了序列化 (writeObject) 和反序列化 (readObject) 方法,保证了序列化和反序列化结果的一致性
-