HashMap源码揭秘
HashMap是基于哈希表实现,以键值对的形式存储，采用了数组和链表的数据结构，能在查询和修改方便继承了数组的线性查找和链表的寻址修改。
概述
1. HashMap是非线程安全的,只适用于单线程环境
2. HashMap实现了Serializable以及Cloneable接口，能被克隆及序列化
3. HashMap允许使用null值和null键.
4. HashMap存储不保证顺序
5. Java8中对此类底层实现进行了优化，比如引入了红黑树的结构以解决哈希碰撞
HashMap的数据结构
HashMap就是数组、链表以及红黑树三种数据结构组成的，从而实现高效率查找。下边是Java8的HashMap数据结构：
HashMap源码分析
1.Node节点类
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; }
//获取hash值。（key的hash值与value的hash值进行异或）
public final int hashCode() {
return Objects.hashCode(key) ^ Objects.hashCode(value);
}
public final V setValue(V newValue) {
V oldValue = value;
value = newValue;
return oldValue;
}
//在比较时，key与value均相等才可返回true
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节点包含一个KV对，还有指向下一个节点的指针next以及hash值,其hash值是key与value先hash后异或所得。具体数据结构如下图：
2.TreeNode节点类
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
TreeNode<K,V> parent; // red-black tree links
TreeNode<K,V> left;
TreeNode<K,V> right;
TreeNode<K,V> prev; // needed to unlink next upon deletion
boolean red;
TreeNode(int hash, K key, V val, Node<K,V> next) {
super(hash, key, val, next);
}
/**
* Returns root of tree containing this node.
*/
final TreeNode<K,V> root() {
for (TreeNode<K,V> r = this, p;;) {
if ((p = r.parent) == null)
return r;
r = p;
}
}
3.HashMap继承体系
public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable {}
HashMap继承自AbstractMap，且实现了Map等接口，因此HashMap是支持序列化以及克隆的，具体如下图所示：
4.HashMap 成员变量
//初始化默认大小，必须为2的指数
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
//表示最大容量
static final int MAXIMUM_CAPACITY = 1 << 30;
//加载因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//转变为红黑树的链表长度域
static final int TREEIFY_THRESHOLD = 8;
//红黑树转为链表（当元素个数小于等于6，由红黑树转为链表）
static final int UNTREEIFY_THRESHOLD = 6;
//当Map里面的数量超过这个值时，表中的桶才能进行树形化 ，否则桶内元素太多时会扩容，
//而不是树形化 为了避免进行扩容、树形化选择的冲突，这个值不能小于4*TREEIFY_THRESHOLD
static final int MIN_TREEIFY_CAPACITY = 64;
//数组
transient Node<K,V>[] table;
//元素具体存放格式
transient Set<Map.Entry<K,V>> entrySet;
//存储元素个数
transient int size;
//修改次数
transient int modCount;
//临界值 当实际大小(容量*填充因子)超过临界值时，会进行扩容
int threshold;
//加载因子（存储个数=容量*加载因子）
final float loadFactor;
5.HashMap构造函数
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);
}
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
public HashMap(Map<? extends K, ? extends V> m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m, false);
}
上边是HashMap的构造函数 。可以看到initialCapacity不允许为负数，但是当initialCapacity为0时，那么threshold为多少？那就看下边tableSizeFor()源码是如何设计的。
6.tableSizeFor()
根据位运算找到大于或等于 cap 的最小2的整数次幂的数比如14，则返回16,具体代码如下：
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;
}
tableSizeFor方法通过右移以及或操作对当前传入cap处理，使其达到大于等于cap的2的幂的数值，整体流程如下图：
无论给定cap(cap < MAXIMUM_CAPACITY )的值是多少,经过以上运算，其值的二进制所有位都会是1。再将其加1，这时候这个值一定是2的幂次方，如果经过运算值大于MAXIMUM_CAPACITY，直接选用MAXIMUM_CAPACITY。
step1:cap - 1又是为了什么？当cap为偶数时，如果经过tableSizeFor且不减1运算，那么计算结果会是当前值的两倍，为了防止这种结果，需要先减1。
loadFactor 负载因子
对于 HashMap 来说,负载因子是一个很重要的参数,该参数反应了HashMap数组的使用情况。通过调节负载因子,可使 HashMap 时间和空间复杂度上有不同的表现。
当我们调低负载因子时，HashMap所能容纳的键值对数量变少。扩容时，重新将键值对存储新的桶数组里，键的键之间产生的碰撞会下降，链表长度变短。此时，HashMap 的增删改查等操作的效率将会变高，这里是典型的拿空间换时间。
相反，如果增加负载因子（负载因子可以大于1），HashMap 所能容纳的键值对数量变多，空间利用率高，但碰撞率也高。这意味着链表长度变长，效率也随之降低，这种情况是拿时间换空间。至于负载因子怎么调节，这个看使用场景了。
一般情况下，我们用默认值就可以了。大多数情况下0.75在时间跟空间代价上达到了平衡所以不建议修改。
7.hashCode()函数
//高16位与低16位进行异或操作
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
可以看到HashMap计算hash值的方式：key的hash值高16位不变，低16位与高16位异或作为key的最终hash值。具体如下图所示：
为什么HashMap要使用这样的方式计算Hash？
//主要和这两行代码有关，具体代码后边会讲到
n = table.length;
index = （n-1） & hash;
现在我们假设数组长度是24，即16，然后计算index索引值，如下图所示：
我们可以看到，只有hash值的低4位参与了运算，当然数组的长度也可能是32，64，那么就是低5、6位，这样总是低几位运算，很容易产生碰撞，因此将高16位与低16位异或，使得高16位也可参与运算，从而减少hash碰撞。个人认为HashMap这种使用右移以及异或来计算hashCode，运算效率高的同时还使得hash碰撞变得更加均匀。妙啊！
核心函数
8.get()函数
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
getNode()函数
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
//index=(n - 1) & hash 计算出 键值对 对应数组下标
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;
//说明第一个元素不是要查找的节点，遍历链表或红黑树查找
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);
}
}
//如果没找到会返回null
return null;
这里我们看到，HashMap会根据(n - 1) & hash计算数组下标，那么put的时候，也肯定是根据这个规则进行插入的。
总结一下get整体流程：
- 根据(n - 1) & hash 计算出所要查找的key在数组对应的下标；
- 判断首个元素是否是所要查找的元素，如果是则直接返回；
- 判断此下标所存储元素是否已经被树化，如果树化则去红黑树查找；
- 否则，遍历单链表，找到直接返回
9.put()函数
public V put(K key, V value) {
//调用hash()来计算key的hash值
return putVal(hash(key), key, value, false, true);
}
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;
//如果table为null则调用resize进行初始化
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//(n - 1) & hash 计算该元素要存放的数组位置
//若此位置为null，则新建节点直接放入对应数组位置（也可以说是一个桶）
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
//表示桶内有元素
else {
Node<K,V> e; K k;
//判断桶内头节点是否与要插入节点key相同，相同则替换
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
//如果该桶内元素已被树化，则走TreeNode的插入
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this,tab,hash,key,value);
//否则走单链表插入（jdk8 使用尾插法）
else {
for (int binCount = 0; ; ++binCount) {
//单链表尾部插入
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
//如果当前桶内元素到8个，则判断（树化或扩容）
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
//如果有相同key，则跳出当前循环
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
//如果e不为null,说明在中途跳出，即e与要插入的元素有相同的key，直接替换value
if (e != null) { y
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);//hashMap这个方法是个空方法
return oldValue;
}
}
++modCount;
//存储元素个数大于threshold，需要扩容
if (++size > threshold)
resize();
afterNodeInsertion(evict);//hashMap不使用（用于LinkeHashMap）
return null;
}
事实上，当我们new HashMap()对象的时候，并没有对table进行初始化，而是在真正put的时候才进行。
总结一下put整体流程：
1. 当桶数组 table 为空时，通过扩容的方式初始化 table
2. 查找要插入的键值对是否已经存在，存在的话根据条件判断是否用新值替换旧值
3. 如果不存在，判断当前桶内元素是否已被树化
4. 如果树化，则对红黑树进行插入操作
5. 如果是链表，则将键值对链入链表中，并根据链表长度决定是否将链表转为红黑树
6. 判断键值对数量是否大于阈值，大于的话则进行扩容操作
其实我们可以看到，如果该插入元素key在HashMap已经存在，则会替换并返回对应的oldValue，否则返回null
扩容机制
在HashMap中，数组的长度总是2的幂，阈值为数组长度与加载因子的乘积，当HashMap中存储的键值对数量大于阈值时，会通过resize函数进行扩容。
HashMap按照当前数组的2倍进行扩容，阈值也会变为原来的两倍（如果计算过程中，阈值溢出归零，则按阈值公式重新计算）。扩容之后，要重新计算键值对的位置，并把它们移动到合适的位置上去。
10.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;
//判断当前数组长度 如果是0则为null
//如果大于0，那就是进行扩容
if (oldCap > 0) {
//判断数组长度是否达到了最大值，则将阈值设置为最大值即可（最大化）
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
//否则将数组长度扩容为原来的两倍，阈值也是一样
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
//如果数组桶容量<=0 且 旧阈值 >0
else if (oldThr > 0)
// 在第一次带参数初始化时候会有这种情况
newCap = oldThr;
//如果数组桶容量<=0 且 旧阈值 <=0
else {
//也表示初始化，赋值为默认值
newCap = DEFAULT_INITIAL_CAPACITY;
//新阈值=默认负载因子*默认容量
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
//如果走到这步，说明数组桶容量<=0 且 旧阈值 >0（看上边）
if (newThr == 0) {
//计算出新阈值赋值给newThr
float ft = (float)newCap * loadFactor;//负载因子*数组容量
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
//将新阈值赋值给threshold
threshold = newThr;
@SuppressWarnings({"rawtypes","unchecked"})
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
//oldTab如果等于null,说明是初始化,直接返回newTab即可
if (oldTab != null) {
//对旧容器里边的元素进行遍历转移 oldCap->newCap
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
//判断数组当前位置是否为null
if ((e = oldTab[j]) != null) {
//将当前位置置为null，help gc
oldTab[j] = null;
//表示当前位置只有一个元素e，直接插入即可
if (e.next == null)
//e.hash & (newCap - 1) 这个似曾相识
//计算新数组对应位置并放入元素
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;
}
具体步骤：
1. 计算新数组的容量newCap和新阈值newThr
2. 根据计算出的newCap创建新数组
3. 将键值对节点重新映射到新的数组里。(遍历旧红黑树或者遍历链表-生成新链或红黑树放入新数组)
**扩容方式： **
**One:**HashMap使用空构造方法，此时table为null且thershold为0，因此会根据DEFAULT_INITIAL_CAPACITY进行扩容
Two: HashMap使用指定初始容量的构造方法初始化，通过代码可以看到初始容量会等于threshold 接着threshold = newCap * DEFAULT_LOAD_FACTOR。 newCap为初始化的计算出来的threshold
**Three:**HashMap不是第一次扩容。如果HashMap已经扩容过的话，那么每次table的容量以及threshold量为原有的两倍。
解析：(e.hash & oldCap) == 0
例1:
假设oldCap=16且hash=6,如下：
上图步骤：
1.获取了oldCap值与hash值，然后进行与操作，得e.hash & oldCap==0
2.重新获得newCap=2oldCap=32
3.对newCap进行(newCap-1)&hash获取当前元素对应数组下标，new_index=6
4.对oldCap进行(oldCap-1)&hash获取旧数组对应下标，old_index=6
得:
new_index == old_index
例2:
假设oldCap=16，hash随机给了一个，目的是为了让 oldCap&hash != 0
上图步骤：
1. 获取了oldCap值与hash值，然后进行与操作，得e.hash & oldCap!=0
2. 重新获得newCap=2oldCap=32
3. 对newCap进行(newCap-1)&hash获取当前元素对应数组下标,new_index=22
4. 对oldCap进行(oldCap-1)&hash获取旧数组对应下标，old_index=6
得:
new_index == old_index+oldCap
总结：
当(e.hash & oldCap) == 0 时，说明扩容后该元素的索引不变，在新数组同样的坐标位置，否则，该元素对应的新数组下标为在原数组下标加上原数组长度。
疑问与解答
1.JDK1.7是基于数组+单链表实现（为什么不用双链表）
首先，用链表是为了解决hash冲突。单链表能实现为什么要用双链表呢?(双链表需要更大的存储空间)
2.为什么要用红黑树，而不用平衡二叉树？
插入效率比平衡二叉树高，查询效率比普通二叉树高。所以选择性能相对折中的红黑树。
3.重写对象的Equals方法时，要重写hashCode方法，为什么？跟HashMap有什么关系？
equals与hashcode间的关系:
如果两个对象相同（即用equals比较返回true），那么它们的hashCode值一定要相同；
如果两个对象的hashCode相同，它们并不一定相同(即用equals比较返回false)
因为在HashMap的链表结构中遍历判断的时候，特定情况下重写的equals方法比较对象是否相等的业务逻辑比较复杂，循环下来更是影响查找效率。所以这里把hashcode的判断放在前面，只要hashcode不相等就玩儿完，不用再去调用复杂的equals了很多程度地提升HashMap的使用效率。
所以重写 hashcode 方法是为了让我们能够正常使用 HashMap 等集合类，因为 HashMap 判断对象是否相等既要比较 hashcode 又要使用 equals 比较。而这样的实现是为了提高 HashMap 的效率。
4.HashMap为什么不直接使用对象的原始hash值呢?
通过移位和异或运算，可以让 hash 变得更复杂，进而影响 hash 的分布性。
5.既然红黑树那么好，为啥hashmap不直接采用红黑树，而是当大于8个的时候才转换红黑树？
因为红黑树需要进行左旋，右旋操作， 而单链表不需要。
以下都是单链表与红黑树结构对比:
如果元素小于8个，查询成本高，新增成本低。
如果元素大于8个，查询成本低，新增成本高。
总结
与JDK1.7相比，JDK1.8确实优化了很多，在底层数据结构引入了红黑树，当一个链表长度大于8的时候，HashMap会动态的将它替换成一个红黑树，这会将时间复杂度从O(n)降为O(logn)。
然而HashMap扩容是一个特别耗性能的操作，所以当在使用HashMap的时候，估算map的大小，初始化的时候给一个大致的数值，避免map进行频繁的扩容。
引用文献：
1.面试必会之HashMap源码分析