转载地址：
JAVA源码分析-HashMap源码分析(一）
https://www.jianshu.com/p/7dcff1fd05ad
JAVA源码分析-HashMap源码分析(二）
https://www.jianshu.com/p/fd22f4965369
HashMap实现原理及源码分析
https://www.cnblogs.com/chengxiao/p/6059914.html
一、什么是哈希表
在讨论哈希表之前，我们先大概了解下其他数据结构在新增，查找等基础操作执行性能
数组：采用一段连续的存储单元来存储数据。对于指定下标的查找，时间复杂度为O(1)；通过给定值进行查找，需要遍历数组，逐一比对给定关键字和数组元素，时间复杂度为O(n)，当然，对于有序数组，则可采用二分查找，插值查找，斐波那契查找等方式，可将查找复杂度提高为O(logn)；对于一般的插入删除操作，涉及到数组元素的移动，其平均复杂度也为O(n)
线性链表：对于链表的新增，删除等操作（在找到指定操作位置后），仅需处理结点间的引用即可，时间复杂度为O(1)，而查找操作需要遍历链表逐一进行比对，复杂度为O(n)
二叉树：对一棵相对平衡的有序二叉树，对其进行插入，查找，删除等操作，平均复杂度均为O(logn)。
哈希表：相比上述几种数据结构，在哈希表中进行添加，删除，查找等操作，性能十分之高，不考虑哈希冲突的情况下，仅需一次定位即可完成，时间复杂度为O(1)，接下来我们就来看看哈希表是如何实现达到惊艳的常数阶O(1)的。
我们知道，数据结构的物理存储结构只有两种：顺序存储结构和链式存储结构（像栈，队列，树，图等是从逻辑结构去抽象的，映射到内存中，也这两种物理组织形式），而在上面我们提到过，在数组中根据下标查找某个元素，一次定位就可以达到，哈希表利用了这种特性，哈希表的主干就是数组。
比如我们要新增或查找某个元素，我们通过把当前元素的关键字 通过某个函数映射到数组中的某个位置，通过数组下标一次定位就可完成操作。
存储位置 = f(关键字)
其中，这个函数f一般称为哈希函数，这个函数的设计好坏会直接影响到哈希表的优劣。举个例子，比如我们要在哈希表中执行插入操作：
查找操作同理，先通过哈希函数计算出实际存储地址，然后从数组中对应地址取出即可。
哈希冲突
然而万事无完美，如果两个不同的元素，通过哈希函数得出的实际存储地址相同怎么办？也就是说，当我们对某个元素进行哈希运算，得到一个存储地址，然后要进行插入的时候，发现已经被其他元素占用了，其实这就是所谓的哈希冲突，也叫哈希碰撞。前面我们提到过，哈希函数的设计至关重要，好的哈希函数会尽可能地保证 计算简单和散列地址分布均匀,但是，我们需要清楚的是，数组是一块连续的固定长度的内存空间，再好的哈希函数也不能保证得到的存储地址绝对不发生冲突。那么哈希冲突如何解决呢？哈希冲突的解决方案有多种:开放定址法（发生冲突，继续寻找下一块未被占用的存储地址），再散列函数法，链地址法，而HashMap即是采用了链地址法，也就是数组+链表的方式。
二、HashMap实现原理
HashMap的主干是一个Node数组。Node是HashMap的基本组成单元，每一个Node包含一个key-value键值对。
Node是HashMap中的一个静态内部类。代码如下
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;
}所以，HashMap的整体结构如下（JDK1.7）
一、HashMap基础
1.1 HashMap的定义
话不多说，首先从HashMap的一些基础开始。我们先看一下HashMap的定义：
public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable
我们可以看出，HashMap继承了AbstractMap<K,V>抽象类，实现了Map<K,V>的方法。
1.2 HashMap的属性
接着，我们通过源码看看HashMap的一些重要的常量属性。
//默认容量
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
//最大容量
static final int MAXIMUM_CAPACITY = 1 << 30;
//默认加载因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//链表转成红黑树的阈值
static final int TREEIFY_THRESHOLD = 8;
//红黑树转为链表的阈值
static final int UNTREEIFY_THRESHOLD = 6;
//存储方式由链表转成红黑树的容量的最小阈值
static final int MIN_TREEIFY_CAPACITY = 64;
//HashMap中存储的键值对的数量
transient int size;
//扩容阈值，当size>=threshold时，就会扩容
int threshold;
//HashMap的加载因子
final float loadFactor;
这里我们要知道<<运算符的意义，表示移位操作，每次向左移动一位(相对于二进制来说)，表示乘以2，此处1<<4表示00001中的1向左移动了4位，变成了10000，换算成十进制就是2^4=16，也就是HashMap的默认容量就是16。Java中还有一些位操作符，比如类似的>>(右移)，还有>>>(无符号右移)等，也是需要我们掌握的。这些位操作符的计算速度很快，我们在平时的工作中可以使用它们来提升我们系统的性能。
这里我们需要加载因子(load_factor)，加载因子默认为0.75，当HashMap中存储的元素的数量大于(容量×加载因子)，也就是默认大于16*0.75=12时，HashMap会进行扩容的操作。
二、初始化
一般来说，我们初始化的时候会这样写：
Map<K,V> map = new HashMap<K,V>();
这个过程发生了什么呢？我们看看源码。
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);
}
我们debug跟踪时，会发现，这里的initialCapacity并不是我们想象的16，而是31，并且会变化几次之后，initialCapacity最终变成了11，这是为什么呢？说实话，我也不清楚，希望有大神可以帮忙解答。
我们继续。初始化时，会首先判断初始容量是否小于0，如果小于0，会抛出异常。接着，判断初始容量是否大于最大的容量(即2^31)，如果大于，将初始容量设置为最大初始容量。紧接着，判断加载因子：如果小于等于0，或者不是一个数字，都会抛出异常。等这些校验完成之后，会将HashMap的加载因子和扩容的阈值设置上。这里需要注意一下，threshold(阈值)=capacity*loadFactor。而我们的阈值是怎么来的呢？我们看一下tableSizeFor()这个方法。
static final int tableSizeFor(int cap) {
int n = cap - 1;
n |= n >>> 1;
n |= n >>> 2;
n |= n >>> 4;
n |= n >>> 8;
n |= n >>> 16;
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}
我们可以看到英文注释：Returns a power of two size for the given target capacity.(返回目标容量对应的2的幂次方。)我们可以想象一下，如果我们将初始值设置为非2的幂次方的数值，比如我们设置为19，最终我们通过这个方法，得到的数组大小是多少呢？我们可以计算一下。
cap=19
int n=cap-1;//得到n=18，换算为二进制为10010
n|=n>>>1;//表示n无符号右移一位后，与n按位或计算，其中n>>>1=01001，按位或结果为11011
n|=n>>>2;//其中n>>>2=00110,按位或的结果为11111，下面几步类似，最终得到的结果是n=11111(二进制，也就是2^5-1，31)
最终计算得到的结果是32
因为cap最大为2^31，我们可以知道，这个方法的最终目的就是返回比cap大的最小的2的幂次方。
三、put()
下面，我们开始解析HashMap中最重要的一个方法:put()。
//如果原来存在相同的key-value，原来的value会被替换掉
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
下面我们首先看一下hash(key)，然后再看一下putVal()方法，这两个方法是精髓。
3.1 hash(key)
先上源码：
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
我们可以发现，当key=null时，也是有hash值的，是0，所以，HashMap的key是可以为null的，对比HashTable源码我们可以知道，HashTable的key直接进行了hashCode，如果key为null时，会抛出异常，所以HashTable的key不可以是null。
我们还能发现hash值的计算，首先计算出key的hashCode()为h，然后与h无条件右移16位后的二进制进行按位异或(^)得到最终的hash值，这个hash值就是键值对存储在数组中的位置。
备注：异或的操作如下：0 ^ 0=0，1 ^ 1 =0，0 ^ 1=1，1 ^ 0=1，也就是相同时返回0，不同时返回1。
我们目前不去深究为什么这么设计，我们只要知道，这样设计的目的是为了让hash值分布的更加均匀即可。
3.2 putVal()方法
3.2.1 源码
我们直接看源码。
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)
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;
}
我们慢慢来分析。首先看入参：
- hash：表示key的hash值
- key：待存储的key值
- value：待存储的value值，从这个方法可以知道，HashMap底层存储的是key-value的键值对，不只是存储了value
- onlyIfAbsent：这个参数表示，是否需要替换相同的value值，如果为true，表示不替换已经存在的value
- evict：如果为false，表示数组是新增模式
我们看到put时所传入的参数put(hash(key), key, value, false, true)，可以得到相应的含义。
3.2.2 HashMap的数据结构
在继续下一步分析之前，我们首先需要看一下HashMap底层的数据结构。（JDK1.8）
HashMap的数据结构
我们可以看到，HashMap底层是数组加单向链表或红黑树实现的(这是JDK 1.8里面的内容，之前的版本纯粹是数组加单向链表实现)。
下面我们看一下HashMap的一些重要的内部类。首先最重要的就是Node类，即HashMap内部定义的单向链表
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> next;
//省略一些代码
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;
}
}
我们重点看一下数据结构，Node中存储了key的hash值，键值对，同时还有下一个链表元素。我们重点关注一些equals这个方法，这个方法在什么时候会用到呢？当我们算出的key的hash值相同时，put方法并不会报错，而是继续向这个hash值的链表中添加元素。我们会调用equals方法来比对key和value是否相同，如果equals方法返回false，会继续向链表的尾部添加一个键值对。
当然，在JDK 1.8中引入了红黑树的概念，内部定义为TreeNode，对红黑树感兴趣的同学可以看看相关的文档，引入红黑树是为了提升查询的效率。
3.2.3 继续分析putVal()方法
首先判断当前HashMap的数组是否为空，如果为空，则调用resize()方法，对HashMap进行扩容，这次扩容的结果就是HashMap的初始化一个长度为16的数组。获取到数组的长度n。代码如下：
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
接着，根据长度-1和hash值进行按位与运算，算出hash值对应于数组中的位置，从tab中将这个位置上面的内容取出，判断为null时，在这个位置新增一个Node。代码如下：
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
// Create a regular (non-tree) node
Node<K,V> newNode(int hash, K key, V value, Node<K,V> next) {
return new Node<>(hash, key, value, next);
}
如果同样的位置取到了数据，也就是这个hash值对应数组的位置上面已经有了键值对存在，这时候我们就需要做一些动作了。首先，我们判断这个Node，也就是p的hash值是否与传入的hash相等，然后接着判断key是否相等(这里判断key是否相等，用了一个或运算)。如果判断通过，表示要传入的key-val键值对就是tab[i]位置上面的键值对，直接替换即可，不用管后面是链表还是红黑树。代码如下：
Node<K,V> e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
如果tab[i]的key不是我们传入的key，下面我们首先要判断p这个Node是不是红黑树，如果是红黑树，直接向红黑树新增一个数据。向红黑树新增数据的代码我们后续再解析，目前先不进行分析。代码如下：
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
下面，当p是单向链表时，我们遍历链表进行插入等操作。找到链表的尾部，将节点新增到尾部。如果链表的长度大于等于红黑树化的阈值-1，就将桶(也就是链表)转成红黑树存储数据。如果在链表中还存在相同的key，直接替换旧的value即可。
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;
}
最后，还有一个操作，大家千万不要忽略，也就是判断当前的键值对数量是否即将超过阈值，如果即将超过，需要进行resize()操作。
if (++size > threshold)
resize();
下面的重点是resize()方法和HashMap中其他的一些方法，希望各位提出宝贵的意见。
话不多说，咱们上源码。
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
//如果老的数组为空，老的数组容量设为0
int oldCap = (oldTab == null) ? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
//如果老的数组容量大于0，首先判断是否大于等于HashMap的最大容量，
//如果true，将阈值设置为Integer的最大值，同时数组容量不变
if (oldCap > 0) {
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
//如果扩容后的数组容量小于我们规定的最大数组容量，而且老的数组容量大于等于16，
//对数组进行扩容，扩容后的数组容量为原来的两倍；同时阈值也扩容为原来的两倍
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
//如果老的数组容量为0，而且老的阈值大于0，则新的容量=老的阈值
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
else { //老的阈值=0，容量和阈值都初始化为默认值，即16和12
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
//如果新的阈值为0，为新的阈值赋值
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)
//如果链表中只有一个数据，直接重新计算hash值，放入新的数组中
newTab[e.hash & (newCap - 1)] = e;
//如果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;
}
上面一段代码的内容比较好理解，都已经根据注释就能看懂，主要的内容在下半部分：扩容后和扩容前，数据存放位置的变化。我们可以理解一下。
经过观测可以发现，我们使用的是2次幂的扩展(指长度扩为原来2倍)，所以，元素的位置要么是在原位置，要么是在原位置再移动2次幂的位置。看下图可以明白这句话的意思，n为table的长度，图（a）表示扩容前的key1和key2两种key确定索引位置的示例，图（b）表示扩容后key1和key2两种key确定索引位置的示例，其中hash1是key1对应的哈希与高位运算结果。
image
元素在重新计算hash之后，因为n变为2倍，那么n-1的mask范围在高位多1bit(红色)，因此新的index就会发生这样的变化：
因此，我们在扩充HashMap的时候，不需要像JDK1.7的实现那样重新计算hash，只需要看看原来的hash值新增的那个bit是1还是0就好了，是0的话索引没变，是1的话索引变成“原索引+oldCap”，可以看看下图为16扩充为32的resize示意图：
这个设计确实非常的巧妙，既省去了重新计算hash值的时间，而且同时，由于新增的1bit是0还是1可以认为是随机的，因此resize的过程，均匀的把之前的冲突的节点分散到新的bucket了。这一块就是JDK1.8新增的优化点。有一点注意区别，JDK1.7中rehash的时候，旧链表迁移新链表的时候，如果在新表的数组索引位置相同，则链表元素会倒置，但是从上图可以看出，JDK1.8不会倒置。
小结
以上就是HashMap中比较重要的源码分析，希望大家能有所收获。高并发时，HashMap还有一些问题，具体是啥问题，大家搜一搜吧，后续可能会出相应的文章，届时再详细解析。所以，在高并发的情况下，还是尽量使用ConcurrentHashMap，后续也会对ConcurrentHashMap的源码进行解析，希望大家关注。
