前言
今天，我们主要来研究一下在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
版权声明：本文为博主原创文章，转载请附上博文链接！
2969
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
