HashMap有何特别之处，为什么java面试从不缺席？
涉及知识点
看过java面试经验分享的小伙伴或者经历过准备过校招面试的小伙伴应该都曾经被Hashmap给支配过，即使是社招HashMap也仍然是高频考点，那么究竟为什么大家都喜欢问HashMap，其中包含了哪些知识点？
- 首先从生产的角度来说，HashMap是我们在生产过程中最常用的集合之一，如果完全不懂它的原理，很难发挥出它的优势甚至会造成线上bug
- 从数据结构和算法的角度，HashMap涉及到了数组，链表，红黑树，以及三者相互转化的过程，以及位运算等丰富的数据结构和算法内容。
所以HashMap就成为了面试的高频考点，这些过程都清楚，说明数据结构和算法的基础不会太差。
HashMap基本知识
JDK1.8之前数据结构是数组+链表
JDK1.8以后采用数组+链表+红黑树
其中，当数组元素超过64个且数组单个位置存储的链表元素个数超过8个时，会进化成红黑树，红黑树的引进时为了加快查找效率
同样，当数组单个位置存储的链表元素个数少于6个时，又会退化成链表
HashMap重要的类属性
其实JDK的源码都有非常详细的注释，但还是翻译一下吧，如下：
- 初始容量大小为16
/**
* The default initial capacity - MUST be a power of two.
*/
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
- 最大容量为2^30
/**
* The maximum capacity, used if a higher value is implicitly specified
* by either of the constructors with arguments.
* MUST be a power of two <= 1<<30.
*/
static final int MAXIMUM_CAPACITY = 1 << 30;
- 默认的负载因子为0.75
负载因子之所以选择是基于时间和空间平衡的结果选择的参数，时间和空间的平衡是指既不浪费太多的空间，又不用频繁地进行扩容
/**
* The load factor used when none specified in constructor.
*/
static final float DEFAULT_LOAD_FACTOR = 0.75f;
- 链表元素数量进化成红黑树的阈值为8，数组元素大于64时，链表元素超过8就会进化为红黑树
/**
* The bin count threshold for using a tree rather than list for a
* bin. Bins are converted to trees when adding an element to a
* bin with at least this many nodes. The value must be greater
* than 2 and should be at least 8 to mesh with assumptions in
* tree removal about conversion back to plain bins upon
* shrinkage.
*/
static final int TREEIFY_THRESHOLD = 8;
至于为什么选8，在之前有一段很长的注释里面有说明，可以看一下原文如下：
* Because TreeNodes are about twice the size of regular nodes, we
* use them only when bins contain enough nodes to warrant use
* (see TREEIFY_THRESHOLD). And when they become too small (due to
* removal or resizing) they are converted back to plain bins. In
* usages with well-distributed user hashCodes, tree bins are
* rarely used. Ideally, under random hashCodes, the frequency of
* nodes in bins follows a Poisson distribution
* (http://en.wikipedia.org/wiki/Poisson_distribution) with a
* parameter of about 0.5 on average for the default resizing
* threshold of 0.75, although with a large variance because of
* resizing granularity. Ignoring variance, the expected
* occurrences of list size k are (exp(-0.5) * pow(0.5, k) /
* factorial(k)). The first values are:
*
* 0: 0.60653066
* 1: 0.30326533
* 2: 0.07581633
* 3: 0.01263606
* 4: 0.00157952
* 5: 0.00015795
* 6: 0.00001316
* 7: 0.00000094
* 8: 0.00000006
* more: less than 1 in ten million
大概意思就是：如果 hashCode的分布离散良好的话，那么红黑树是很少会被用到的，因为各个值都均匀分布，很少出现链表很长的情况。在理想情况下，链表长度符合泊松分布，各个长度的命中概率依次递减，注释中给我们展示了1-8长度的具体命中概率，当长度为8的时候，概率概率仅为0.00000006，这么小的概率，HashMap的红黑树转换几乎不会发生
- 红黑树元素少于6个就退化成链表
至于为什么是6个不是7个是为了避免频繁在树与链表之间变换，如果是7，加一个元素就需要进化成红黑树，删一个元素就需要退化成链表
/**
* The bin count threshold for untreeifying a (split) bin during a
* resize operation. Should be less than TREEIFY_THRESHOLD, and at
* most 6 to mesh with shrinkage detection under removal.
*/
static final int UNTREEIFY_THRESHOLD = 6;
- 链表树能进化成树时最小的数组长度，只有数组长度打到这个值链表才可能进化成树
/**
* The smallest table capacity for which bins may be treeified.
* (Otherwise the table is resized if too many nodes in a bin.)
* Should be at least 4 * TREEIFY_THRESHOLD to avoid conflicts
* between resizing and treeification thresholds.
*/
static final int MIN_TREEIFY_CAPACITY = 64;
重要的内部类
链表Node<K,V>
定义的链表Node类，next有木有很熟悉，单向链表
/**
* Basic hash bin node, used for most entries. (See below for
* TreeNode subclass, and in LinkedHashMap for its Entry subclass.)
*/
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;
}
public final K getKey() { return key; }
public final V getValue() { return value; }
public final String toString() { return key + "=" + value; }
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;
}
}
红黑树TreeNode<K,V>
/**
* Entry for Tree bins. Extends LinkedHashMap.Entry (which in turn
* extends Node) so can be used as extension of either regular or
* linked node.
*/
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;
}
}
HashMap的put方法
实际上调用的是putVal方法
/**
* Associates the specified value with the specified key in this map.
* If the map previously contained a mapping for the key, the old
* value is replaced.
*
* @param key key with which the specified value is to be associated
* @param value value to be associated with the specified key
* @return the previous value associated with <tt>key</tt>, or
* <tt>null</tt> if there was no mapping for <tt>key</tt>.
* (A <tt>null</tt> return can also indicate that the map
* previously associated <tt>null</tt> with <tt>key</tt>.)
*/
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
接下来看看putVal方法
/**
* Implements Map.put and related methods
*
* @param hash hash for key
* @param key the key
* @param value the value to put
* @param onlyIfAbsent if true, don't change existing value
* @param evict if false, the table is in creation mode.
* @return previous value, or null if none
*/
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;
}
putVal的流程如下：
HashMap的resize扩容方法（重要）
先翻译一下这个方法的官方注释：
初始化或者将原来的容量翻倍，如果为空，则分配初始容量，否则，进行容量翻倍，原来存在的元素要么留在原来的位置上，要么在新的数组中向后移动原来数组容量的大小
/**
* Initializes or doubles table size. If null, allocates in
* accord with initial capacity target held in field threshold.
* Otherwise, because we are using power-of-two expansion, the
* elements from each bin must either stay at same index, or move
* with a power of two offset in the new table.
*
* @return the table
*/
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) {
// 超过最大值就不再扩充了，就只好随你碰撞去吧
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
// 没超过最大值，就扩充为原来的2倍
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
//初始化，申明HashMap的时候指定了初始容量
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
//初始化，申明HashMap的时候没有指定初始容量
else { // zero initial threshold signifies using defaults
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
// 计算新的resize上限
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)
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;
}
整个扩容的流程如下：
链表重新整理的过程
可能会将原来一个链表拆分为两个链表，判断当前链表元素是否需要移动到新的链表的依据是：
计算(e.hash & oldCap) == 0？
true，不需要移动到另一个链表，我们用头结点为loHead的链表将这些元素串起来
false，元素需要移动到另一个新的链表，我们用头结点为hiHead的链表将这些元素串起来
（tips:其实lo和hi是low和high的缩写，这里用的是两个双指针来进行链表的拆分整理）
以数组从容量为16扩容到32为例，位于下标为1的链表扩容之后如图所示：一部分链表仍然保留在下标为1的位置，另一部分则迁移至下标为1+16的位置。
在链表重新整理的过程中，同一个链表的元素的相对顺序不会被改变
红黑树重新整理的过程
看了一下TreeNode的继承关系，TreeNdoe也是继承Node的子类，红黑树重新整理的过程也和链表相似，因为它其实也维护了一个链表的结构
拆分可能会将原来一个红黑树拆分为两个链表，或者一个红黑树一个链表，判断当前链表元素是否需要移动到新的链表的依据是：
计算(e.hash & oldCap) == 0？
true，不需要移动，仍然在原来的位置，我们用头结点为loHead的链表将这些元素串起来，如果元素的个数不小于6，则继续维护成红黑树，否则为链表
false，元素需要移动到另一个新的位置，我们用头结点为hiHead的链表将这些元素串起来，如果元素的个数不小于6，则继续维护成红黑树，否则为链表
HashMap线程安全性
HashMap中存在的线程安全问题：
1.HashMap在读取Hash槽首元素的时候读取的是工作内存中引用所指向的对象，并发情况下，其他线程修改的值并不能被及时读取到。
2.HashMap在插入新元素的时候，主要会进行两次判断：
2.1 第一次是根据键的hash判断当前hash槽是否被占用，如果没有就放入当前插入对象。并发情况下，如果A线程判断该槽未被占用，在执行写入操作时时间片耗尽。此时线程B也执行获取hash(恰巧和A线程的对象发生hash碰撞)判断该槽未被占用，继而直接插入该对象。然后A线程被CPU重新调度继续执行写入操作，就会将线程B的数据覆盖。(注：此处也有可见性问题)
2.2 第二次是同一个hash槽内，因为HashMap特性是保持key值唯一，所以会判断当前欲插入key是否存在，存在就会覆盖。与上文类似，并发情况下，如果线程A判断最后一个节点仍未发现重复key那么会把以当前对象构建节点挂在链表或者红黑树上，如果线程B在A判断操作和写操作之间，进行了判断和写操作，也会发生数据覆盖。
除此之外扩容也会发生类似的并发问题。还有size的问题，感觉其实高并发情况下这个size的准确性可以让步性能。
参考文章
【1】tech.meituan.com/2016/06/24/…
【2】blog.csdn.net/weixin_3143…
作者：ForeverKobe
链接：https://juejin.cn/post/7033392478753390629
来源：稀土掘金
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。
