HashMap详解以及常见面试题
一、概要
本文先会将hashmap的基本概念属性梳理一遍后，再从增删改查方法中每个步骤逐一解释说明。力求达到通熟易懂，逻辑清晰，便于加深印象。
二、概念
首先Hashmap的底层数据结构是由数组+链表组成的，是线程不安全，允许key和value为null。底层结构数组叫哈希桶，而桶内则是链表，链表中的节点Node存放着实际的元素。
Hashmap中获取元素时的主要流程步骤为，首先对key值进行hash算法得出hash值即哈希桶中的索引值，再找到对应的hash桶。如果存在，则通过（拉链法）链表从前往后比较value值是否相等，直到找到元素或下个节点为null时。
而增加元素或修改元素的主要流程步骤与获取相类似，不同在于当增加元素后，如果总元素size大于阈值时，会发生扩容。
在JDK8中，加强了hash算法的效率以及利用率，当桶内元素大于8和所有元素总数大于64时，将链表转换为红黑树，优化了扩容时的算法。
三、分解
1. hash算法
在上面概念中讲到，hash算法是计算key值对应哈希桶的位置即索引值。我们都知道数组在获取元素会比链表快，所以我们应该尽量让每个哈希桶只有一个元素，这样在查询时就只需要通过索引值找到对应的哈希桶内的值，而不需要再通过桶内的链表一个一个去查。所以hash算法的作用是为了让元素分散均匀，从而提高查询效率。那接下来通过代码来一步一步分析时如何让元素分布均匀的。
//这是根据key值获取value值的方法
public V get(Object key) {
Node<K,V> e;
//先调用hash(key)
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
//Hash算法如下
static final int hash(Object key) {
int h;
//第一步：先获取key中的hashCode值
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
//第二步 再与hashcode向左移16位的值进行抑或
}
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 &&
//第三步 n是指数组长度，hash与(n-1)进行&与运算
(first = tab[(n - 1) & hash]) != null) {
//省略
...
...
}
return null;
}首先第一步获取hashcode没什么问题，到第二步为什么会跟hashcode左移16位的值进行抑或呢? 其实是将高位与低位进行与运算，减少碰撞机率。第三步取余运算，但在计算机运算中**&肯定比%快**，又因为h % n = h &（n - 1），所以最终将第二步得到的hash跟n-1进行与运算。n是table中的长度。
2、get方法，查询元素
查询get方法相对简单，只要明白hash算法后得到哈希桶的索引值，再对桶内的链表进行比较hash，key是否相等。下面是get方法中主要的代码
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
//如果表为null或长度为0，或者经过hash算法后得到的哈希桶为null，则直接返回null
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
//如果链表中的第一个节点元素相等则直接返回该Node
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);
//否则循环链表找到对应相等的元素，直到找到或下个节点为null
do {
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}3.1put方法，增加(JDK1.7)
public Object put(Object key, Object value) {
key = this.convertKey(key);//key为null则用new Object()代替。
int hashCode = this.hash(key);//得出key的hash值，但这个hash值不是key本身的hash值，是经过复杂运算的。
int index = this.hashIndex(hashCode, this.data.length);//根据key的hash值和全局数组data的长度得出数组下标。
//遍历下标为“index”的全局数组data，如果有“相等”key已经存在，那么替换掉。
for(HashMap_put.HashEntry entry = this.data[index]; entry != null; entry = entry.next) {
//判断key是否已经存在；（entry.hashCode就是key的hash值）
if(entry.hashCode == hashCode && this.isEqualKey(key, entry.key)) {
Object oldValue = entry.getValue();//把旧的值赋给oldValue
this.updateEntry(entry, value);//用新的value把旧的value替换掉
return oldValue;//把替换掉的旧value，返回
}
}
//新增键值对让我们的注意力------》转移到addMapping这个方法上。
this.addMapping(index, hashCode, key, value);
return null;protected void addMapping(int hashIndex, int hashCode, Object key, Object value) {
++this.modCount;//修改次数加一。
HashMap_put.HashEntry entry = this.createEntry(this.data[hashIndex], hashCode, key, value);//创建一个内部类entry
this.addEntry(entry, hashIndex);//为全局数组data添加一个entry
++this.size;//HashMap的size加一。
this.checkCapacity();//检查HashMap是否需要扩大容量让我们的注意力转移到checkCapacity这个方法上。3.2 put方法，增加(JDK1.8)
put方法是重点也是最复杂的操作。需要掌握在什么情况下要扩容（后面会讲一下是如何扩容的），满足什么条件下链表需要转成红黑树。下面是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)
n = (tab = resize()).length;
//如果哈希桶为null，则创建节点放在该桶内
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
Node<K,V> e; K k;
//如果桶内第一个元素hash相等，key相等，则更新此节点
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
//判断是否为红黑树，若是则调用红黑树的putTreeVal
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
//循环链表
for (int binCount = 0; ; ++binCount) {
//知道下个节点为null时
if ((e = p.next) == null) {
//增加节点
p.next = newNode(hash, key, value, null);
//如果桶内的节点是否大于8
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
//这个方法里还会判断总节点数大于64则会转换为红黑树
treeifyBin(tab, hash);
break;
}
//如果找到相等的节点则退出循环
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
//只有找到相等节点是e不为null
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.扩容
扩容是Hashmap重点中的重点。也是最耗性能的操作。扩容的步骤是先对size扩大两倍，再对原先的节点重新经过hash算法得到新的索引值即复制到新的哈希桶里。最后得到新的table。其中jdk8对扩容进行了优化，提高了扩容的效率。但在平常运用中尽量要避免让hashmap进行扩容，若已知hashmap中的元素数量，则一开始初始化hashmap时指定容量，这样就减少了hashmap扩容次数。
```java
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) {
//如果容量大于了最大容量时，直接返回旧的table
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
}
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;
if (oldTab != null) {
//接下来对哈希桶的所有节点转移到新的哈希桶中
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
//如果哈希桶为null，则不需任何操作
if ((e = oldTab[j]) != null) {
//将桶内的第一个节点赋值给e
//将原哈希桶置为null，让gc回收
oldTab[j] = null;
if (e.next == null)
//如果e的下个节点（即第二个节点）为null，则只需要将e进行转移到新的哈希桶中
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode)
//如果哈希桶内的节点为红黑树，则交给TreeNode进行转移
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // preserve order
//将桶内的转移到新的哈希桶内
//JDK1.8后将新的节点插在最后面
//下面就是1.8后的优化
//1.7是将哈希桶的所有元素进行hash算法后转移到新的哈希桶中
//而1.8后，则是利用哈希桶长度在扩容前后的区别，将桶内元素分为原先索引值和新的索引值（即原先索引值+原先容量）。这里不懂为什么，可以看下一段图文讲解。
//loHead记录低位链表的头部节点
//loTail是低位链表临时变量，记录上个节点并且让next指向当前节点
Node<K,V> loHead = null, loTail = null;
//hiHead，hiTail与上面的一样，区别在于这个是高位链表
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
//用于临时记录当前节点的next节点
next = e.next;
//e.hash & oldCap==0表示扩容前后对当前节点的索引值没有发生改变
if ((e.hash & oldCap) == 0) {
//loTail为null时，代表低位桶内无元素则记录头节点
if (loTail == null)
loHead = e;
else
//将上个节点next指向当前节点
//即新的节点是插在链表的后面
loTail.next = e;
//将当前节点赋值给loTail
loTail = e;
}
else {
//跟上面的步骤是一样的。
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
//当next节点为null则退出循环
} while ((e = next) != null);
//如果低位链表记录不为null，则低位链表放到原index中
if (loTail != null) {
//将最后一个节点的next属性赋值为null
loTail.next = null;
newTab[j] = loHead;
}
//如果高位链表记录不为null，则高位链表放到新index中
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}1.8对扩容方法进行了优化，经过rehash之后，元素的位置要么是在原位置，要么是在原位置再移动2次幂的位置。 看下图可以明白这句话的意思，n为table的长度，图（a）表示扩容前的key1和key2两种key确定索引位置的示例，图（b）表示扩容后key1和key2两种key确定索引
元素在重新计算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不会倒置
参考：resize方法详解
总结下通过分析代码后的一些心得
运算尽量用位运算代替，比较高效。例如hash算法中的取模运算，用&n-1去替代%n方法，元素起来更加高效
变量不用以后要赋值为null，让gc进行回收
当桶内节点大于8和节点总数大于64时才会转换为红黑树，前者在putValue中验证，后者treeifyBin方法中判断
扩容时，对容量进行扩大两倍后，原链表上的节点可能存放在原来的下表即low位。或者是存放在high位。high = low + oldCapacity
四、常见的面试题
1.HashMap底层是如何实现的？
首先底层数据结构是由数组+链表组成链表散列。HashMap先得到key的散列值，在通过扰动函数（减少碰撞次数）得到Hash值，接着通过hash & （n -1 ），n位table的长度，运算后得到数组的索引值。如果当前节点存在元素，则通过比较hash值和key值是否相等，相等则替换，不相等则通过拉链法查找元素，直到找到相等或者下个节点为null时。1.8对扰动函数，扩容方法进行优化，并且增加了红黑树的数据结构。
2.HashMap 和 Hashtable 的区别
线程安全 HashMap是线程不安全的，而HashTable是线程安全的，每个人方法通过修饰synchronized来控制线程安全。
效率 HashMap比HashTable效率高，原因在于HashTable的方法通过synchronized修饰后，并发的效率会降低。
允不允许null HashMap运行只有一个key为null，可以有多个null的value。而HashTable不允许key，value为null。
3.HashMap的长度为什么是2的倍数
在HashMap的操作流程中，首先会对key进行hash算法得到一个索引值，这个索引值就是对应哈希桶数组的索引。为了得到这个索引值必须对扰动后的数跟数组长度进行取余运算。即 hash % n (n为hashmap的长度)，又因为&比%运算快。n如果为2的倍数，就可以将%转换为&，结果就是 hash & (n-1)。所以这就解释了为什么HashMap长度是2的倍数。
4.Jdk1.8中满足什么条件后将链表转化成红黑树？
很显然在putVal方法中是判断桶内的节点个数是否大于8，之后通过treeifyBin方法中判断长度是否大于最小红黑树容量64,小于则继续扩容，大于则转为红黑树。
//putVal方法判断桶内元素是是否大于8
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
//treeifyBin方法中判断长度是否大于最小红黑树容量64,小于则继续扩容，大于则转为红黑树
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
resize();五、JDK从1.7到1.8对HashMap的优化
- 由 数组+链表 的结构改为 数组+链表+红黑树。
拉链过长会严重影响hashmap的性能，所以1.8的hashmap引入了红黑树。
在链表元素数量超过8时改为红黑树，少于6时改为链表，中间7不改是避免频繁转换降低性能。
相对于链表，改为红黑树后碰撞元素越多查询效率越高。链表O(n)，红黑树O(logn)。 - 优化了高位运算的hash算法：h^(h>>>16)
将hashcode无符号右移16位，让高16位和低16位进行异或。 - 扩容后，元素要么是在原位置，要么是在原位置再移动2次幂的位置，且链表顺序不变。
不需要重新计算hash，只需要根据原来hash值新增的bit是1还是0分别放进两个链表lo和hi（非红黑树的情况）里，0的话索引没变，1的话索引变为原索引加原来的数组长度。
因为用的尾插法所以新数组链表不会倒置，多线程下不会出现死循环。
六、CurrentHashMap的线程安全问题
- CurrentHashMap Base JDK1.7
如图所示，是由 Segment 数组、HashEntry 组成，和 HashMap 一样，仍然是数组加链表。
它的核心成员变量：
/**
* Segment 数组，存放数据时首先需要定位到具体的 Segment 中。
*/
final Segment<K,V>[] segments;
transient Set<K> keySet;
transient Set<Map.Entry<K,V>> entrySet;Segment 是 ConcurrentHashMap 的一个内部类，主要的组成如下：
static final class Segment<K,V> extends ReentrantLock implements Serializable {
private static final long serialVersionUID = 2249069246763182397L;
// 和 HashMap 中的 HashEntry 作用一样，真正存放数据的桶
transient volatile HashEntry<K,V>[] table;
transient int count;
transient int modCount;
transient int threshold;
final float loadFactor;
}看看其中 HashEntry 的组成：
和 HashMap 非常类似，唯一的区别就是其中的核心数据如 value ，以及链表都是 volatile 修饰的，保证了获取时的可见性。
原理上来说：ConcurrentHashMap 采用了分段锁技术，其中 Segment 继承于 ReentrantLock。不会像 HashTable 那样不管是 put 还是 get 操作都需要做同步处理，理论上 ConcurrentHashMap 支持 CurrencyLevel (Segment 数组数量)的线程并发。每当一个线程占用锁访问一个 Segment 时，不会影响到其他的 Segment。
下面也来看看核心的 put get 方法。
put 方法
public V put(K key, V value) {
Segment<K,V> s;
if (value == null)
throw new NullPointerException();
int hash = hash(key);
int j = (hash >>> segmentShift) & segmentMask;
if ((s = (Segment<K,V>)UNSAFE.getObject // nonvolatile; recheck
(segments, (j << SSHIFT) + SBASE)) == null) // in ensureSegment
s = ensureSegment(j);
return s.put(key, hash, value, false);
}首先是通过 key 定位到 Segment，之后在对应的 Segment 中进行具体的 put。
final V put(K key, int hash, V value, boolean onlyIfAbsent) {
HashEntry<K,V> node = tryLock() ? null :
scanAndLockForPut(key, hash, value);
V oldValue;
try {
HashEntry<K,V>[] tab = table;
int index = (tab.length - 1) & hash;
HashEntry<K,V> first = entryAt(tab, index);
for (HashEntry<K,V> e = first;;) {
if (e != null) {
K k;
if ((k = e.key) == key ||
(e.hash == hash && key.equals(k))) {
oldValue = e.value;
if (!onlyIfAbsent) {
e.value = value;
++modCount;
}
break;
}
e = e.next;
}
else {
if (node != null)
node.setNext(first);
else
node = new HashEntry<K,V>(hash, key, value, first);
int c = count + 1;
if (c > threshold && tab.length < MAXIMUM_CAPACITY)
rehash(node);
else
setEntryAt(tab, index, node);
++modCount;
count = c;
oldValue = null;
break;
}
}
} finally {
unlock();
}
return oldValue;
}虽然 HashEntry 中的 value 是用 volatile 关键词修饰的，但是并不能保证并发的原子性，所以 put 操作时仍然需要加锁处理。
首先第一步的时候会尝试获取锁，如果获取失败肯定就有其他线程存在竞争，则利用 scanAndLockForPut() 自旋获取锁。
- 尝试自旋获取锁。
- 如果重试的次数达到了 MAX_SCAN_RETRIES 则改为阻塞锁获取，保证能获取成功
再结合图看看 put 的流程。
- 将当前 Segment 中的 table 通过 key 的 hashcode 定位到 HashEntry。
- 遍历该 HashEntry，如果不为空则判断传入的 key 和当前遍历的 key 是否相等，相等则覆盖旧的 value。
- 不为空则需要新建一个 HashEntry 并加入到 Segment 中，同时会先判断是否需要扩容。
- 最后会解除在 1 中所获取当前 Segment 的锁。
get 方法
public V get(Object key) {
Segment<K,V> s; // manually integrate access methods to reduce overhead
HashEntry<K,V>[] tab;
int h = hash(key);
long u = (((h >>> segmentShift) & segmentMask) << SSHIFT) + SBASE;
if ((s = (Segment<K,V>)UNSAFE.getObjectVolatile(segments, u)) != null &&
(tab = s.table) != null) {
for (HashEntry<K,V> e = (HashEntry<K,V>) UNSAFE.getObjectVolatile
(tab, ((long)(((tab.length - 1) & h)) << TSHIFT) + TBASE);
e != null; e = e.next) {
K k;
if ((k = e.key) == key || (e.hash == h && key.equals(k)))
return e.value;
}
}
return null;
}get 逻辑比较简单：
只需要将 Key 通过 Hash 之后定位到具体的 Segment ，再通过一次 Hash 定位到具体的元素上。
由于 HashEntry 中的 value 属性是用 volatile 关键词修饰的，保证了内存可见性，所以每次获取时都是最新值。
ConcurrentHashMap 的 get 方法是非常高效的，因为整个过程都不需要加锁。
Base 1.8
1.7 已经解决了并发问题，并且能支持 N 个 Segment 这么多次数的并发，但依然存在 HashMap 在 1.7 版本中的问题。
那就是查询遍历链表效率太低。
因此 1.8 做了一些数据结构上的调整。
首先来看下底层的组成结构：
看起来是不是和 1.8 HashMap 结构类似？其中抛弃了原有的 Segment 分段锁，而采用了 CAS + synchronized 来保证并发安全性。
也将 1.7 中存放数据的 HashEntry 改为 Node，但作用都是相同的。
其中的 val next 都用了 volatile 修饰，保证了可见性。
put 方法
重点来看看 put 函数：
- 根据 key 计算出 hashcode 。
- 判断是否需要进行初始化。
- f 即为当前 key 定位出的 Node，如果为空表示当前位置可以写入数据，利用 CAS 尝试写入，失败则自* 旋保证成功。
- 如果当前位置的 hashcode == MOVED == -1,则需要进行扩容。
- 如果都不满足，则利用 synchronized 锁写入数据。
- 如果数量大于 TREEIFY_THRESHOLD 则要转换为红黑树。
get 方法
- 根据计算出来的 hashcode 寻址，如果就在桶上那么直接返回值。
- 如果是红黑树那就按照树的方式获取值。
- 就不满足那就按照链表的方式遍历获取值。
1.8 在 1.7 的数据结构上做了大的改动，采用红黑树之后可以保证查询效率（O(logn)），甚至取消了 ReentrantLock 改为了 synchronized，这样可以看出在新版的 JDK 中对 synchronized 优化是很到位的。
总结
看完了整个 HashMap 和 ConcurrentHashMap 在 1.7 和 1.8 中不同的实现方式相信大家对他们的理解应该会更加到位。
其实这块也是面试的重点内容，通常的套路是：
谈谈你理解的 HashMap，讲讲其中的 get put 过程。
1.8 做了什么优化？
是线程安全的嘛？
不安全会导致哪些问题？
如何解决？有没有线程安全的并发容器？
ConcurrentHashMap 是如何实现的？ 1.7、1.8 实现有何不同？为什么这么做？
这一串问题相信大家仔细看完都能怼回面试官。
除了面试会问到之外平时的应用其实也蛮多，像之前谈到的 Guava 中 Cache 的实现就是利用 ConcurrentHashMap 的思想。
同时也能学习 JDK 作者大牛们的优化思路以及并发解决方案。
