前言
今天,我们主要来研究一下在Java8中HashMap的数据结构及一些重要方法的具体实现。
研究HashMap的源代码之前,我们首先来研究一下常用的三种数据结构:数组、链表和红黑树。
数组作为一种基本的数据结构,以线性的方式组织数据,按数据的插入顺序来排列数据。在内存中,数组的物理组织形式是一段连续的内存空间。在数据操作上,由于数组的物理特点,可以在O(1)的时间复杂度内完成数据的查找,在插入和删除上需要更长的时间(O(n)的时间复杂度)。
链表在逻辑特性上基本与数组保持一致,同样以线性的方式组织数据,按数据的插入顺序来排列数据。在内存中,链表的物理组织形式是离散的磁盘空间,通过指针进行不同链表节点的链接,因此在数据的插入和删除上具有非常好的性能,可以达到O(1)的时间复杂度,但是在查找上面性能较差,需要O(n)的时间复杂度。
红黑树是一种经过了优化的平衡二叉树,可以在数据的插入上获得更好的性能。首先红黑树在数据的查找上可以达到O(nlog(n))的时间复杂度,同时数据的插入和删除,可以实现局部调整,从而可以承担更少的性能代价(相较于平衡二叉树)。
HashMap的设计就是为了在查找上获得最优的性能(希望基本获取O(1)的时间复杂度),因此HashMap主要使用了数组作为核心的数据存储的结构,同时使用链地址法解决K-V映射时产生的碰撞,在Java8中同时加入了红黑树来优化碰撞时数据匹配的性能。HashMap的组织形式大致如下图所示:
HashMap的映射方法
Java8中结合元素自身的hashcode以及再hash的方式来获取元素的哈希值,在通过取模的方式映射到数组中,其中取模运算是通过优化后的位运算来实现的。首先来看一下元素的hashcode的获取方法:
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
>>> 是无符号右移操作符,h >>> 16是将h右移16位,左边高位补16个0;^ 是异或操作,相同的为0,不同的为1,即 0 ^ 1 = 1; 0 ^ 0 = 0;所以,(h = key.hashCode()) ^ (h >>> 16)意思是 key的hash值高16位不变,低16位与高16位异或作为key的最终hash值。(h >>> 16,表示无符号右移16位,高位补0,任何数跟0异或都是其本身,因此key的hash值高16位不变。)
接下来看一看如何使用该哈希值做映射,为了说明方便我们使用Java7中的indexFor函数来做说明,在Java8中虽然没有显示的这个函数了,但该函数的具体实现被嵌入到了具体的各个方法中了。
static int indexFor(int h, int length) {
return h & (length-1);
}
如上,需要解释两个问题,
1)如何使用位运算&来实现取模运算。
2)在HashMap中,数组table的长度为啥必须为2的n次方。
首先来解释第一个问题1)如何使用位运算&来实现取模运算。先来看一个简单的例子,当数组的长度为16的时候,实现取模运算和位运算&时候的结果如下:
key&(table.length-1) | 二进制 | index | key%(table.length-1) | index |
4&15 | 100&1111 | 100 | 4%15 | 4 |
13&15 | 1101&1111 | 1101 | 13%15 | 13 |
19&15 | 10011&1111 | 11 | 19%15 | 4 |
由上表可知,可以通过位运算&的方式,实现hashcode的映射,将不同的hashcode映射到不同的数组下标中,并且如表所知,可以通过hashcode的末几位决定映射后的下标位置。同时可以知道,实际上hashcode的很多位是用不上的,因此在HashMap的hash函数中,才使用了移位运算,只取了hashcode的前16位来做映射。
同时另一方面,虽然通过对2^n-1做&运算不会和%运算获得同样的结果,但是能够将hashcode做一个均匀的散列,其效果完全等同于取模运算,并且会有更优的运算性能。
因此第二个问题2)HashMap中,数组table的长度为啥必须为2的n次方的第一个层面就回答完了,为了在&运算中,使元素在数组中映射的更均匀,达到%运算的效果,所以将数组的大小必须设定位2的n次幂。同时该大小的设定还有第二个层次的原因,具体我们将在resize函数的解析中,做进一步的剖析,请继续研读下去。
HashMap数据结构分析
//HashMap中数组的默认大小
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
//HashMap中数组所允许的最大容量
static final int MAXIMUM_CAPACITY = 1 << 30;
//HashMap的默认装载因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//构造红黑树的阀值
static final int TREEIFY_THRESHOLD = 8;
根据代码上方的注释可以知道这4个关键参数的具体含义,首先HashMap的初始数组大小为16,并且允许的最大大小为2的30次方,其中装载因子为0.75,这个值可以根据具体的需求,传入HashMap的构造函数中做更改,同时构造红黑树的默认阀值是8。HashMap中存储K-V的具体结构为一个实现了Map.Entry<K,V>接口的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;
}
//......
具体的K-V操作就是基于该Node类的,可以看到其中的键是一个final修饰的变量,final所修饰的变量具有一定的线程安全性,具体的分析见多线程语意分析。
HashMap重要方法实现分析
1)构造函数HashMap解析:
首先来研究一下Java8中的HashMap的初始化,不同于Java7中的构造方法,Java8对于数组table的初始化,并没有直接放在构造器中完成,而是将table数组的构造延迟到了resize中完成,具体来看一看他的构造函数:
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所支持的最大容量时,容量会被置为MAXIMUM_CAPACITY,同时对装载因子进行初始化(装载因子决定数组何时进行扩容)。如上所示,不同于Java7,在构造函数中并没有对table数组进行初始化,具体的构造,我们将后面的resize函数解析中做具体的分析。
2)get函数解析:
通过传入的key,返回其对应的value,在Java8的源码中可以看到,该函数的执行是依赖于getNode函数的,具体代码及注释分析如下:
final Node<K,V> getNode(int hash, Object key) {
//变量说明:tab用于存储table引用,first用于存储数组中第一个节点,e为目标节点
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
//首先确保当前HashMap不为空,同时通过映射后Key所对应的数组位置节点不为空
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
//当前if框架内,是当前位置发生hash碰撞后的节点,框架内是对节点的匹配
//hash值相等的情况下,进行key值的匹配
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;
}
代码中除了对基础逻辑的分析以外,还需要注意的是,进行key匹配的时候,同时需要hash值相等和key的值相等才算匹配成功,因此这里进一步的证明了需要要求hashcode与equal保持一致(即可回答一个经典的面试问题:当hashcode进行重写了也必须重写equals方法,反之亦然)。同时可以看到,Java8中引入的红黑树,在进行节点匹配时,需要进行节点的类型检测,在链表和红黑树之间调用不同的检测接口进行匹配。
另一方面还需要注意,对于值匹配的判断中,只要引用相等或值相等的其中之一成立即成立。
3)put函数解析:
put函数的实现,具体依赖于putNode方法的实现,put函数的逻辑由于需要考虑更多情况则会更加的复杂,首先我们通过流程图来具体看一看put函数的具体实现逻辑:
如上图所示,为整个put操作的逻辑,其中需要注意以下几点:
- put操作会进行进行为空的检测,当为空时进行resize扩容
- 当put的key存在时,会分别在数组头、红黑树或者链表中进行节点匹配,匹配成功后进行value值的更新
接下来我们来具体看一看putNode的代码与分析:
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为空的检测
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//对hash进行映射,并检测数组头是否为空,为空则直接创建新的节点
if ((p = tab[i = (n - 1) & hash]) == null)
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;
}
4)resize函数解析
整个HashMap中,最为精髓和核心的函数即为resize函数了,通过上文的分析可知,很多函数都将依赖put操作的执行,同时很多HashMap的设计,也都集中在resize函数当中。对于resize函数的分析,将着重的从两点并行出发,首先会分析resize函数的代码逻辑,其次会对上文提出的问题进行回答。
首先来看看在Java8中,扩容的具体逻辑是怎样的。我们在上文中提出了一个问题,即HashMap的数组大小为什么必须为2的n次幂,我们对其作出了一个层次的回答,而其第二个层次的回答就在resize函数的执行逻辑中。在Java8的扩容中,不是简单的将原数组中的每一个元素取出进行重新hash映射,而是做移位检测。所谓移位检测的含义具体是针对HashMap做映射时的&运算所提出的,通过上文对&元算的分析可知,映射的本质即看hash值的某一位是0还是1,当扩容以后,会相比于原数组多出一位做比较,由多出来的这一位是0还是1来决定是否进行移位,而具体的移位距离,也是可知的,及位原数组的大小,我们来看下表的分析,假定原表大小为16:
HashCode(Java8中只使用高16位) | size=16 | size=32 | 移位情况 |
0101 1010 0011 1101 | 0101101000111101&1111 | 0101101000111101&11111 | 向前移动16位 |
1011 0111 1000 0101 | 1011011110000101&1111 | 1011011110000101&11111 | 不移动 |
1110 0100 0001 0001 | 1110010000010001&1111 | 1110010000010001&1111 | 向前移动16位 |
由上表可知,是否移位,由扩容后表示的最高位是否为所决定,并且移动的方向只有一个,即向高位移动。因此,可以根据对最高位进行检测的结果来决定是否移位,从而可以优化性能,不用每一个元素都进行移位。
接下来我们来看一看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;
//对原始数组长度进行检测
if (oldCap > 0) {
//若数组长度已经达到HashMap所设计的最大长度,则不能进行扩容,只将阀值设置为最大
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
//检测将数组长度扩大一倍后是否在HashMap所设计的最大长度范围内
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double 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"})
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
//将HashMap进行重置
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)
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;
}
代码中最核心的部分即为对扩容后的数组的重建,不同于Java7中数组的构建,Java8采用了尾插法,保证了新构建的数组与原数组在碰撞后的元素组织次序的一致。同时还需要注意的是,HashMap不通过线程安全的支持,因此在数组扩容的过程中会造成死循环,具体出现死循环的情况可参见相关博客。
后言
以上就是对Java8中HashMap的代码和逻辑的分析,如有不正之处,请望指出~
Java8中HashMap不支持线程安全的问题已经存在很多年了,官方也没有打算去解决其死循环的问题,对于需要线程安全的场景,官方更推荐使用ConcurrentHashMap类,后续也会有对该类的分析,敬请期待~
同时需要进行Java研发类求职的朋友可以仔细研读本博客,其中很多小点都是Java面试的常见问题,同时也望多关注本人其他Java类博客,望支持,谢谢~
---------------------
作者:beacon-7
来源:CSDN
原文:https://blog.csdn.net/u014454539/article/details/80528795
版权声明:本文为博主原创文章,转载请附上博文链接!