文章目录
前言
本章开始前,首先介绍一下HashMap:
HashMap是一个用来存储键值对(key-value)的集合,键值都可使用null,并且键不能重复,每一个键值对都是一个Entry。
在谈hashmap的扩容机制前,首先得现了解其底层原理,这样能够帮助我们更好理解为什么要这样进行扩容,ok,让我们开始进入主题:
一、哈希表
1.简介
散列表(Hash table,也叫哈希表),是根据关键码值(Key value)而直接进行访问的数据结构。也就是说,它通过把关键码值映射到表中一个位置来访问记录,以加快查找的速度。这个映射函数叫做散列函数,存放记录的数组叫做散列表。
2.HashMap与哈希表的关系
HashMap底层是一个table数组+链表+红黑树(jdk1.8之前是数组+链表)实现的哈希表存储结构。这种实现方法是最常用的一种方法——拉链法。
3.特点
数组的特点:寻址快,插入和删除效率低;
链表的特点:寻址慢,插入和删除效率高。
使用拉链法构造的哈希表结合了数组和链表的优点:寻址快,插入和删除效率高。
二、HashMap底层实现原理
1.主干数组
transient Node<K,V>[] table; //HashMap的主干数组
2.链表节点
静态内部类:Node实现了Entry接口
static class Node<K,V> implements Map.Entry<K,V> {
final int hash; //hash值
final K key;
V value;
Node<K,V> next; //指向下一节点
Node(int hash, K key, V value, Node<K,V> 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() { //返回node的hash码
return Objects.hashCode(key) ^ Objects.hashCode(value);
}
public final V setValue(V newValue) { //key重复时覆盖旧值,并返回旧值
V oldValue = value;
value = newValue;
return oldValue;
}
public final boolean equals(Object o) { //重写了equals方法
if (o == this) //地址相同时,返回true
return true;
if (o instanceof Map.Entry) { //如果o是Map.Entry的一个实例
Map.Entry<?,?> e = (Map.Entry<?,?>)o;
//o和this的键值都相同,则返回true
if (Objects.equals(key, e.getKey()) &&
Objects.equals(value, e.getValue()))
return true;
}
return false;
}
}
3.树节点
树节点,继承了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可以看出,HashMap底层数据结构是table数组+链表+红黑树。结构图如下图所示:
4.链表与红黑树间的转化
-为什么要转化?
在jdk1.7及之前的版本中,HashMap的底层实际是table数组+链表,但是存在一种极端情况:如果频繁发生hash冲突,数据将会集中在链表上,那么花费在查找数据的时间会大大增加(链表查找数据的时间复杂度是O(n)),所以在jdk1.8时,增加了树形化功能,将达到阈值的链表转换为具有平衡性的红黑树(时间复杂度是O(logn))。
-转化临界值
static final int TREEIFY_THRESHOLD = 8; //树形化临界值:8
static final int UNTREEIFY_THRESHOLD = 6; //树转链表临界值
static final int MIN_TREEIFY_CAPACITY = 64; //可以树形化的容器的最小表容量
- TREEIFY_THRESHOLD:当链表长度增大到8时,链表会转化为红黑树;
- UNTREEIFY_THRESHOLD:当链表长度减小到6时,红黑树会转化为链表;
- MIN_TREEIFY_CAPACITY:当表容量(数组大小)大于或等于64时,才允许链表树形化,否则进行扩容。(该值应该至少是4 * TREEIFY_THRESHOLD,以避免调整大小和树形化阈值之间的冲突)
三、HashMap扩容机制
1.构造方法
- 无参构造:
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // 负载因子,默认为0.75
}
负载因子 DEFAULT_LOAD_FACTOR 默认取0.75,例:当HashMap的容量(table数组的大小)为16,已经使用了3/4的空间,则会进行扩容操作。
static final float DEFAULT_LOAD_FACTOR = 0.75f;
- 有参构造:
public HashMap(int initialCapacity) {
//使用默认负载因子
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
2.容量
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; //默认初始化容量为16
static final int MAXIMUM_CAPACITY = 1 << 30; //最大容量
- 使用无参构造方法时,初始容量为16
- 使用有参构造方法时,容量为2的幂次方,如下:
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); //容量
}
自定义HashMap初始容量大小时,执行tableSizeFor方法:
static final int tableSizeFor(int cap) {
int n = cap - 1; //cap=65 --> n=1000000(二进制)
n |= n >>> 1; //1000000 | 0100000 = 1100000
n |= n >>> 2; //1100000 | 0011000 = 1111000
n |= n >>> 4; //1111000 | 0000111 = 1111111
n |= n >>> 8; //1111111 | 1111111 = 1111111
n |= n >>> 16; //1111111 | 1111111 = 1111111 (127)
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}
通过该方法,能将自定义容量rap扩大到最近的2^n,例如cap = 65时,最终容量大小为128,即2^7。
为什么容量要是2的幂次方呢?
我们知道,计算数组下标时通常是用hash值对数组长度进行取模运算,java中则使用按位与运算,如下:
(n - 1) & hash
当n为2的幂次方时,(n - 1) & hash 的值与取模运算结果是一致的(例如:n=2,hash=3,计算得数组下标为1,即数组的第二个位置),并且使用按位与运算速度比取模运算快。
3.扩容
resize:
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table; //table数组
//旧数组为空时返回0,否则返回旧数组长度
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; //调整扩容阈值大小为2^31-1
return oldTab;
}
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
//新数组容量扩大为原来的2倍
//新数组容量小于容量最大值 且 旧数组容量大于或等于16
newThr = oldThr << 1; // 扩容阈值增大为原来的2倍
}
//初始化时
else if (oldThr > 0) // 有参构造,oldCap == 0
newCap = oldThr; //此时oldThr为自定义得出的初始容量(例如:自定义65,最终为128)
else { //使用无参构造方法时
newCap = DEFAULT_INITIAL_CAPACITY; //默认初始化数组容量-->16
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); //0.75 * 16
}
if (newThr == 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;
if ((e = oldTab[j]) != null) { //当前下标对应的空间中存在数据时
oldTab[j] = null; //将该空间清空
if (e.next == null)
//e为单一节点时,重新计算下标,并将e放入新数组中
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode)
//存储的是红黑树时
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // 存储的是链表时
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; //低位头指针指向e
else
loTail.next = e;
loTail = e; //低位尾指针指向e
}
else {
if (hiTail == null)
hiHead = e; //高位头指针指向e
else
hiTail.next = e;
hiTail = e; //高位尾指针指向e
}
} while ((e = next) != null);
if (loTail != null) {
loTail.next = null;
/*
此时的j等于hash & (newCap-1),证明如下:
令oldCap = 2^m,则newCap = 2^(m+1),
因为Cap都是2的幂次方,所以第 m+1位是1,后面均为0,
当hash & oldCap == 0时,
则(oldCap的第 m+1位) & (hash的第 m+1位) = 0,
得出hash的第 m+1位为0,
newCap - 1后,则由m个1与hash进行运算
hash:x x x x . . . 0 x1 x2 x3 ...
old-1: 0 1 1 1 ... m个1
new-1: 0 1 1 1 1 ... m+1个1
由上可得:hash & (oldCap - 1) == hash & (newCap - 1)
*/
newTab[j] = loHead;
}
if (hiTail != null) { //hash的第 m+1位是1,则结果加上2^m
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
总结
- HashMap底层数据结构为:数组+链表+红黑树;
- 使用无参构造方法创建HashMap时,初始化容量默认为16;
- 使用无参构造方法创建HashMap时,初始化容量为2的幂次方;
- HashMap默认负载因子为0.75;
- HashMap扩容时容量为原先的2倍;
- HashMap扩容后,其内数据会重新排列。(数组下标计算满足:hash & (capacity - 1))