简介
Java为数据结构中的映射定义了一个接口java.util.Map,它根据键的hashCode值存储数据,大多数情况下可以直接定位
到它的值,因而具有很快的访问速度,但遍历顺序却是不确定的。 HashMap最多只允许一条记录的键为null,允许多条记
录的值为null。HashMap非线程安全,即任一时刻可以有多个线程同时写HashMap,可能会导致数据的不一致。如果需要满
足线程安全,可以用 Collections的synchronizedMap方法使HashMap具有线程安全的能力,或者使用ConcurrentHashMap。
内部实现
搞清楚HashMap,首先需要知道HashMap是什么,即它的存储结构-字段;其次弄明白它能干什么,即它的功能实现-方法。
存储结构-字段
从结构实现来讲,HashMap是数组+链表+红黑树(JDK1.8增加了红黑树部分)实现的,如下如所示。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-D4fyLnfu-1661395649426)(https://p3-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/39ff6d0428a0448b98286b30b8073d36~tplv-k3u1fbpfcp-watermark.image?)]
HashMap内部类Node
static class Node<K,V> implements Map.Entry<K,V> {
final int 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() {
return Objects.hashCode(key) ^ Objects.hashCode(value);
}
public final V setValue(V newValue) {
V oldValue = value;
value = newValue;
return oldValue;
}
public final boolean equals(Object o) {
if (o == this)
return true;
if (o instanceof Map.Entry) {
Map.Entry<?,?> e = (Map.Entry<?,?>)o;
if (Objects.equals(key, e.getKey()) &&
Objects.equals(value, e.getValue()))
return true;
}
return false;
}
}
从源码可知,HashMap类中有一个非常重要的字段,就是 Node[] table,即哈希桶数组,明显它是一个Node的数组。
Node是HashMap的一个内部类,实现了Map.Entry接口,本质是就是一个映射(键值对)。
上图中的每个黑色圆点就是一个Node对象。
HashMap就是使用哈希表来存储的。哈希表为解决冲突,可以采用开放地址法和链地址法等来解决问题,Java中HashMap
采用了链地址法。链地址法,简单来说,就是数组加链表的结合。在每个数组元素上都有一个链表结构,当数据被Hash后,
得到数组下标,把数据放在对应下标元素的链表上。
例如:
执行:map.put(“美团”,“小美”);
系统将调用“美团”这个key的hashCode()方法得到其hashCode 值(该方法适用于每个Java对象),然后再通过Hash算法
的后两步运算(高位运算和取模运算)来定位该键值对的存储位置,有时两个key会定位到相同的位置,表示发生了Hash
碰撞。当然Hash算法计算结果越分散均匀,Hash碰撞的概率就越小,map的存取效率就会越高。
如果哈希桶数组很大,即使较差的Hash算法也会比较分散,如果哈希桶数组数组很小,即使好的Hash算法也会出现较多碰
撞,所以就需要在空间成本和时间成本之间权衡,其实就是在根据实际情况确定哈希桶数组的大小,并在此基础上设计好
的hash算法减少Hash碰撞。
那么通过什么方式来控制map使得Hash碰撞的概率又小,哈希桶数组(Node[] table)占用空间又少呢?
答案就是好的Hash算法和扩容机制。
在理解Hash和扩容流程之前,我们得先了解下HashMap的几个字段。从HashMap的默认构造函数源码可知,构造函数就是对下面几个字段进行初始化,源码如下:
/**
* The number of key-value mappings contained in this map.
*/
transient int size; // HashMap中实际存在的键值对数量
/**
* The number of times this HashMap has been structurally modified
* Structural modifications are those that change the number of mappings in
* the HashMap or otherwise modify its internal structure (e.g.,
* rehash). This field is used to make iterators on Collection-views of
* the HashMap fail-fast. (See ConcurrentModificationException).
*/
transient int modCount; // HashMap内部结构发生变化的次数
/**
* The next size value at which to resize (capacity * load factor).
*/
// (The javadoc description is true upon serialization.
// Additionally, if the table array has not been allocated, this
// field holds the initial array capacity, or zero signifying
// DEFAULT_INITIAL_CAPACITY.)
int threshold; // 所能容纳的key-value对极限
/**
* The load factor for the hash table.
*/
final float loadFactor; // 负载因子
首先,Node[] table的初始化长度length(默认值是16),Load factor为负载因子(默认值是0.75),threshold是HashMap
所能容纳的最大数据量的Node(键值对)个数。threshold = length * Load factor。也就是说,在数组定义好长度之后,
负载因子越大,所能容纳的键值对个数越多。
结合负载因子的定义公式可知,threshold就是在此Load factor和length(数组长度)对应下允许的最大元素数目,超过这
个数目就重新resize(扩容),扩容后的HashMap容量是之前容量的两倍。默认的负载因子0.75是对空间和时间效率的一个
平衡选择,建议大家不要修改,除非在时间和空间比较特殊的情况下,如果内存空间很多而又对时间效率要求很高,可以
降低负载因子Load factor的值;相反,如果内存空间紧张而对时间效率要求不高,可以增加负载因子loadFactor的值,
这个值可以大于1。
size这个字段其实很好理解,就是HashMap中实际存在的键值对数量。注意和table的长度length、容纳最大键值对数量
threshold的区别。而modCount字段主要用来记录HashMap内部结构发生变化的次数,主要用于迭代的快速失败。强调一
点,内部结构发生变化指的是结构发生变化,例如put新键值对,但是某个key对应的value值被覆盖不属于结构变化。
在HashMap中,哈希桶数组table的长度length大小必须为2的n次方(一定是合数),这是一种非常规的设计,常规的设计是
把桶的大小设计为素数。相对来说素数导致冲突的概率要小于合数。Hashtable初始化桶大小为11,就是桶大小设计为素数
的应用(Hashtable扩容后不能保证还是素数)。HashMap采用这种非常规设计,主要是为了在取模和扩容时做优化,同时
为了减少冲突,HashMap定位哈希桶索引位置时,也加入了高位参与运算的过程。
这里存在一个问题,即使负载因子和Hash算法设计的再合理,也免不了会出现拉链过长的情况,一旦出现拉链过长,则会
严重影响HashMap的性能。于是,在JDK1.8版本中,对数据结构做了进一步的优化,引入了红黑树。而当链表长度太长
(默认超过8)时,链表就转换为红黑树,利用红黑树快速增删改查的特点提高HashMap的性能,其中会用到红黑树的插入、
删除、查找等算法。
功能实现-方法
HashMap的内部功能实现很多,这里主要从根据key获取哈希桶数组索引位置、put方法的详细执行、扩容过程三个具有代表性的点深入展开讲解。
根据key获取哈希桶数组索引位置
先看源码:
/*---------------------------------------------------jdk1.8------------------------------------------------------*/
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
/**
* 此处分为两步:
* h = key.hashCode() 第一步,获取hashCode值
* h ^ (h >>> 16) 第二步,将hashCode的高16位异或hashCode的低16位来获得一个新的hash值
* h >>> 16: 将h右移16位
* h ^ (h >>> 16): ^表示如果是同值取 0、异值取 1
*/
/*---------------------------------------------------jdk1.7------------------------------------------------------*/
static int hash(int h) {
// This function ensures that hashCodes that differ only by
// constant multiples at each bit position have a bounded
// number of collisions (approximately 8 at default load factor).
h ^= (h >>> 20) ^ (h >>> 12);
return h ^ (h >>> 7) ^ (h >>> 4);
}
对于任意给定的对象,只要它的hashCode()返回值相同,那么程序调用hash(Object key)所计算得到的Hash码值总是相同的。我们首先想到的就是把hash值对数组长度取模运算,这样一来,元素的分布相对来说是比较均匀的。但是,模运算的消耗还是比较大的。
取模运算表现在getNode(int hash, Object key)和putVal(int hash, K key, V value, boolean onlyIfAbsent, boolean evict)方法中,源码如下:
/*
* getNode方法
*/
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) { // (n - 1) & hash为取模运算
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;
}
/**
* putVal方法
*/
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null) // (n - 1) & hash为取模运算
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
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) {
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 = e;
}
}
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
如上述源码中所示,(n - 1) & hash为取模运算,这里使用的是&而不是%,这是因为当hash值为2的n次方时,&运算比%运算更加高效,这样可以缓解取模运算消耗较大的缺点。根据官方的解释,hash值之所以取hashCode()高16位的值异或低16位的值,是从速度、功效、质量来考虑的,这么做可以在数组table的length比较小的时候,也能保证考虑到高低Bit都参与到Hash的计算中,同时不会有太大的开销。
注意:此处的n表示table的长度,也就是HashMap扩容前的大小,默认为16。
JDK1.7与1.8的区别
hash()方法又称扰动函数。使用 hash 方法也就是扰动函数是为了防止一些实现比较差的 hashCode() 方法 换句话说使
用扰动函数之后可以减少碰撞。
jdk1.7中,进行了四次扰动之后获得hash值,通过indexFor()方法,进行取模运算,最终得到索引值。
jdk1.8中,只进行了一次扰动就获得hash值,然后在putVal()、getNode()方法中,都有使用(n - 1) & hash进行取模运
算。
jdk1.8相比较jdk1.7,效率提高了。
分析HashMap的put方法
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是否为null或length是否为0
if ((tab = table) == null || (n = tab.length) == 0)
// 调用resize方法进行扩容
n = (tab = resize()).length;
// i = (n - 1) & hash 获取hashCode值进行高低16位异或的值再进行取模运算,得到插入的数组索引i,判断tab(i)是否为null
if ((p = tab[i = (n - 1) & hash]) == null)
// 如果为null则直接创建新的节点插入该位置
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
// 如果新插入数据的key与发生冲突的node节点的key相同,则记录下来
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
// 判断冲突的node的节点是否是红黑树结构
else if (p instanceof TreeNode)
// 调用红黑树的插入方法
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
// 发生冲突的node节点还是链表结构
else {
// 遍历链表
for (int binCount = 0; ; ++binCount) {
// 如果遍历到链表的末节点,依旧未发现key相同的数据
if ((e = p.next) == null) {
// 在链表的末端创建新节点,插入数据
p.next = newNode(hash, key, value, null);
// 插入数据后,判断链表的长度是否达到红黑树要求
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
// 转换为红黑树
treeifyBin(tab, hash);
break;
}
// 如果发现新插入的key值与链表已存在的key值相同,记录下来
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
// 判断节点不为null
if (e != null) { // existing mapping for key
V oldValue = e.value;
// 如果onlyIfAbsent的值为true,则不替换
if (!onlyIfAbsent || oldValue == null)
e.value = value;
// 这句是为了LinkedHashMap排序操作,HashMap中无用处。HashMap为无序
afterNodeAccess(e);
return oldValue;
}
}
// modCount加一,modCount字段主要用来记录HashMap内部结构发生变化的次数
++modCount;
// 如果新加入元素之后HashMap的长度达到容量的极限,则进行扩容。
// size是HashMap中实际存在的键值对数量。
// threshold是HashMap所能容纳的最大数据量的Node(键值对)个数。
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
具体流程图如下:
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-A0N5jg7T-1661395649428)(https://p1-juejin.byteimg.com/tos-cn-i-k3u1fbpfcp/7047140159f342f4b43fe8bfab462be3~tplv-k3u1fbpfcp-watermark.image?)]
JDK1.7与1.8的区别
jdk1.7中,HashMap底层使用的数据结构是数组和链表。
jdk1.8中,HashMap底层使用的数据结构是数组、链表和红黑树。默认当链表长度超过8时,就会转换为红黑树。
使用红黑树代替链表的原因是,红黑树查找节点的时间复杂度为O(logn),而遍历链表所需要的时间复杂度为O(n),因此为了提高HashMap的效率,在链表过长时会转换为红黑树。
扩容机制
扩容(resize)就是重新计算容量,向HashMap对象里不停的添加元素,而HashMap对象内部的数组无法装载更多的元素时,对象就需要扩大数组的长度,以便能装入更多的元素。当然Java里的数组是无法自动扩容的,方法是使用一个新的数组代替已有的容量小的数组。这些操作都是在HashMap中的resize()方法中实现的。
resize()方法源码如下:
final Node<K,V>[] resize() {
/*----------------------------第一部分,初始化容器----------------------------*/
// 获取旧的table
Node<K,V>[] oldTab = table;
// 获取旧table的实际长度
int oldCap = (oldTab == null) ? 0 : oldTab.length;
// 获取旧的table容量
int oldThr = threshold;
int newCap, newThr = 0;
// 判断旧table长度是否大于0
if (oldCap > 0) {
// 判断旧table实际长度是否大于为容量的最大值
// static final int MAXIMUM_CAPACITY = 1 << 30;
if (oldCap >= MAXIMUM_CAPACITY) {
// 将threshold设置为int的最大值
threshold = Integer.MAX_VALUE;
return oldTab;
}
// << 1操作即地位补0的方式,与 *2 的效果一样且速度更快
// 判断两倍的旧table实际长度是否会小于容量最大值,旧table的实际长度是否大于等于16
// static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
// 新的容器容量为旧容器容量的两倍
newThr = oldThr << 1; // double threshold
}
// 如果hashtable尚未定义,则初始化定义容量以及threshold
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
else { // zero initial threshold signifies using defaults
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;
@SuppressWarnings({"rawtypes","unchecked"})
//生成新的newTab来替换之前的oldTable
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
/*----------------------------第二部分,数据替换----------------------------*/
// 判断旧table中是否有值
if (oldTab != null) {
// 遍历旧table
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
// 遍历判断节点是否为空
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
// 判断当前节点是否为最后一个节点
if (e.next == null)
// 重新计算索引值,将node节点放入
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;
// 利用取模运算计算新的索引值,如果索引值不需要修改,则由loHead链表来保存
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
// 利用取模运算计算新的索引值,如果索引值需要修改,则由hiHead链表来保存
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
// 循环结束,如果不需要修改索引位置的node,则直接将loHead保存到newTab[j]中
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
// 如果需要修改索引位置的node,则直接将hiTail保存到newTab[j + oldCap]中
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
源码解析如下:
第一部分:初始化容器
扩容,就是使用一个新的容器来替换旧的容器。HashMap为了优化取模的速度,让哈希桶的长度必须为2的n次方,所以每
一次扩容都是在原有哈希桶的大小上扩充一倍。
通过:newCap = oldCap << 1; newThr = oldThr << 1;这种位偏移的方式,相当于newCap = oldCap * 2; 但是效率会
更高,在计算机中,位运算的速度更快。
如果哈希桶的容量仍未定义,也会进行数据初始化。
第二部分:使用newTab替换oldTab中的数据
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) { // 计算当前节点的索引,判断为0还是为1
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) { // 为0则表示索引不变
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) { // 为1则新索引 = 原索引 + 原容量
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
jdk1.7旧链表迁移新链表的时候,如果在新表的数组索引位置相同,则链表元素会倒置。
jdk1.8中,由于哈希桶的长度一定是2的n次方,所以对Node的重新计算索引也就是hash值对length - 1重新取模的索引
值,要么是原索引,要么是原索引+原长度。这主要取决于hash值新增的那一位bit是0还是1。如果是0的话,新索引就还
是原索引;如果是1的话,新索引就是原索引+原长度。所以重新计算索引时根本不需要重新计算它们的位置,只需要判
断新增的那一位bit是0还
是1就可以了,大大优化了效率。
源码中使用 (e.hash & oldCap) == 0 进行判断,为true则依旧是原索引,为false则为原索引+原长度。
jdk1.8中创建了两个链表:loHead和hiHead。
loHead用来存放索引不变的节点;hiHead用来存放索引改变的节点。在while循环结束的时候,进行判断是否为空,就能
将节点存放到对应位置,不需要与JDK1.7一样倒置。
get方法解析
public V get(Object key) {
Node<K,V> e;
// 根据key获取hash值,通过hash值获取到key对应的数据,为空则返回null,不为空则返回key对应的数据
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;
// 判断table是否为空,表的长度是否小于0,以及索引对应的表数据是否为null
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;
// 判断节点e是否为末尾节点
if ((e = first.next) != null) {
// 判断节点是否为红黑树
if (first instanceof TreeNode)
// 通过调用红黑树的api获取对应hash和key的节点
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);
}
}
// key对应的数据不存在,则返回null
return null;
}
线程安全性
在多线程使用场景中,应该尽量避免使用线程不安全的HashMap,而使用线程安全的ConcurrentHashMap。
HashMap的一些操作并不具备原子性,在多线程的场景中,可能会出现两个线程同时进行操作,导致出现死循环等错误。
参考资料
美团技术团队:# Java 8系列之重新认识HashMap
个人博客:# 探究JDK1.8中HashMap的实现原理