一、哈希表
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;
}
}
...
}
从上文可以看出，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.容量
//默认初始化容量为16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
//最大容量
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.扩容
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)
//新数组容量小于容量最大值 且 旧数组容量大于或等于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)）
