HashMap集合是Map这个接口下的实现类中最为常用的一种，也是面试中经常会被问到的问题之一。由于HashMap用到的数据结构较为复杂，与其相关的问题通常不好回答，尤其是在jdk1.8之后，又引入了红黑树结构，其数据结构变得更加复杂，接下来我们就以1.8版本为例，对HashMap进行一波分析，在进行1.8版本之前，我们先来看看1.7版本的，有哪些不足和问题，为什么会在1.8引进红黑树这个结构等等问题。
—JAVA JDK 1.7 版本HashMap—
JDk1.7版本HashMap中的哈希表实现是数组+链表实现的，这里对哈希表还不熟悉的小伙伴可以先看看这篇文章Java集合源码分析（二）：哈希表；
对于1.7版本我们这里不细说源码，我们就只把里面比较重要的一些点拿出来讲：
1、初始容量 
初始容量必须为2的幂，因为这里 << 左移运算，左移一位2的1次幂，左移四位也就是2的4次方==16
2、构造函数初始化问题
在初始化的时候，哈希桶并没有立即开辟空间，而是在传递第一个值的时候才开辟空间，并在上面我么提到，初始容量必须为2的幂，但是在初始化构造对象的时候，我们可以传任意的参数。例如17，它刚好比2的4次幂大一，
在扩容膨胀的时候，会向上调整至2的5次方幂，也就是32，这个时候就满足17的容量，但有个问题，就是太浪费空间。
3、Hash函数，将HashCode映射成int值（0–n-1，n为哈希桶的个数）
源码中是 hash & (length-1) ，当length为2的幂时，length-1的二进制表示为111…11，就是都为1，如果出现0，就意味着无论谁与它按位与的结果都是0，全为1的话吗，我们就可以通过按位与的方法快速得到数组下标（哈希桶实质上是一个数组），包括hash操作，用了很多次异或操作，太骚了，这里就不拿出来说了。
4、resize–扩容
resize方法里面的transfer方法会是1.7版本hashMap很多问题的根源，后面再说这些问题。
都知道每一个哈希桶实际上是一个链表，这里一个一个去遍历，也就涉及到效率高低的问题。
java7就是对数组+哈希表+链表的一个实现，有兴趣的同学可以自行去查看源码，这里就不做多的说明了，接下来我们来说一说Java7中HashMap存在的一些问题，正因为有了这些问题，才会出现后来的Java8版本的HashMap。
1、资源浪费问题
上面也提到过很多资源浪费的问题，在 hashmap1.7 是使用 N 个链表组成的数据结构，使用空间换时间的思想，使用数组把创建的 N 个链表关联起来，其本质上还是对链表的操作。如果在计算 hashCode 的值存在 hash 碰撞严重的话，那么所有的 entry 都会集中到数组某一个元素对应的链表上，这就并不能减少对 entry 的增删改查的时间消耗，反而会因为创建底层的数据而占用过多的内存空间，而这些节点的存在都没有实际的意义，造成一定程度的内存浪费。尤其是在resize的时候，整个Hash表里的无素都需要被重算一遍。这叫rehash，这个成本相当的大。
2、非常容易出现的死锁问题
主要问题其实还是在用户身上，因为1.7中注释明确说明HashMap不是线程安全的。
我们把transfer方法简化一下：
void transfer(Entry[] newTable, boolean rehash) {
for (Entry<K,V> e : table) {
while(null != e) {
Entry<K,V> next = e.next;
e.next = newTable[i];
newTable[i] = e;
e = next;
}
}
}
假设现在有两个线程 t1 丶 t2 和 t3 在运行这段代码，当 t1 线程运行了 e.next = newTable[i]; 的时候， t2 执行 next = e.next; 然后 t3 运行 newTable[i] = e; 和 e = next; 那么就会存在 e.next = newTable[i]; 和 newTable[i].next = e; 形成一个环形链表，从而造成死循环。
3、潜在的安全隐患
CVE-2011-4858和Tomcat邮件组的讨论，这两个小伙伴可以自行去搜索了解。
可以通过精心构造的恶意请求引发DOS，String的hashCode方法是通过每个字符计算哈希值，所以容易产生哈希碰撞，例如 “Aa”, “BB”, “C#” 的哈希值都是2112。
所以1.7中的hash()方法中先判断了如果是String，用另一种方法（不是String提供的hashCode）来计算哈希值，避免潜在攻击，这个链表可能会很长，那么put/get操作都可能需要遍历这个链表，也就是说时间复杂度退化到了O(n)的级别。严重拖慢服务器响应速度。
1.7版本的我们就讲这些，接下俩我们来看看1.8版本的，看看它是怎么解决以上问题的。
JAVA JDK 1.8 版本HashMap
我们看看1.8版本的hashMap有哪些主要的改变？
1、数据+链表/红黑树
2、扩容时插入顺序的改进
3、函数方法 foreach和compute系列
4、Map的新API–merge和replace
一、成员变量
这里我们就只写几个最重要的参数。其他的参数小伙伴们可以自行去源码细细品尝。
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;
static final int UNTREEIFY_THRESHOLD = 6;
static final int MIN_TREEIFY_CAPACITY = 64;
这里我们主要介绍三个参数，也是接下俩构造器中接触最多的三个参数
1、 initialCapacity 初始容量（默认16）： hashMap底层由数组实现+链表（或红黑树）实现，但是还是从数组开始，所以当储存的数据越来越多的时候，就必须进行扩容操作，如果在知道需要储存数据大小的情况下，指定合适的初始容量，可以避免不必要的扩容操作，提升效率
2、 threshold 阈值：hashMap所能容纳的最大价值对数量，如果超过则需要扩容，计算方式：threshold=initialCapacity*loadFactor（构造方法中直接通过tableSizeFor(initialCapacity)方法进行了赋值，主要原因是在构造方法中，数组table并没有初始化，put方法中进行初始化，同时put方法中也会对threshold进行重新赋值，这个会在后面的源码中进行分析）
3、 loadFactor 加载因子（默认0.75）：当负载因子较大时，去给table数组扩容的可能性就会少，所以相对占用内存较少（空间上较少），但是每条entry链上的元素会相对较多，查询的时间也会增长（时间上较多）。反之就是，负载因子较少的时候，给table数组扩容的可能性就高，那么内存空间占用就多，但是entry链上的元素就会相对较少，查出的时间也会减少。所以才有了负载因子是时间和空间上的一种折中的说法。所以设置负载因子的时候要考虑自己追求的是时间还是空间上的少。（一般情况下不需要设置，系统给的默认值已经比较适合了）
这两个成员变量，当桶里的值达到8的时候，就要把链表变成红黑树了，至于为什么是8，这里为8的时候，是符合泊松分布的。
二、构造方法
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);
}
对于很多刚入手Java的小伙伴来说，我们一般最常用的就是无参构造器了，
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
可以看到在这个构造器里面仅仅设置了加载因子为默认值，其他两个参数会在resize方法里面进行初始化，在这里知道这个结论就可以了，下面我们会在源码里面进行分析；另外一个带有两个参数的构造方法，里面对初始容量和阈值进行了初始化，会阈值的初始化方法为tableSizeFor(int cap),我们来一起看一下源码：
/**
* 找到大于或等于 cap 的最小2的幂
*/
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;
}
我相信有81%的小伙伴们看到这个都是一脸懵逼，这到底是什么意思啊？说一个笑话，这里刚看的时候我也不懂，于是乎去搜索相关的博客和资料才得到以下这个结果：
这里我们以10为例：
最后在说明一下，第一步 int n = cap - 1; 这个操作，执行这个操作的主要原因是为了防止在cap已经是2的n次幂的情况下，经过运算后得到的结果是cap的二倍的结果，例如如果n为l6，经过一系列运算之后，得到的结果是0001 1111，此时最后一步n+1 执行之后，就会返回32，感兴趣的朋友可以再去好好自己尝试一下。
三、HashMap的一些重要方法
put方法
在HashMap这一模块中，put方法的实现逻辑应该是最麻烦的，接下俩我们来一起看看源码：
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
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)
//如果table尚未初始化，则此处进行初始化数组，并赋值初始容量，重新计算阈值
n = (tab = resize()).length;
if ((p = tab[i = (n - 1) & hash]) == null)
//通过hash找到下标，如果hash值指定的位置数据为空，则直接将数据存放进去
tab[i] = newNode(hash, key, value, null);
else {
//如果通过hash找到的位置有数据，发生碰撞
Node<K,V> e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
//如果需要插入的key和当前hash值指定下标的key一样，先将e数组中已有的数据
e = p;
else if (p instanceof TreeNode)
//如果此时桶中数据类型为 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;
}
//如果链表中有新插入的节点位置数据不为空，则此时e 赋值为节点的值，跳出循环
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
//经过上面的循环后，如果e不为空，则说明上面插入的值已经存在于当前的hashMap中，那么更新指定位置的键值对
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
//如果此时hashMap size大于阈值，则进行扩容
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
从源码中我们可以看到，put方法可分为三种：
1、 table尚未初始化，对数据进行初始化
2、 table已经初始化，且通过hash算法找到下标所在的位置数据为空,直接将数据存放到指定位置
3、 table已经初始化，且通过hash算法找到下标所在的位置数据不为空，发生hash冲突（碰撞），发生碰撞后，会执行以下操作：
*判断插入的key如果等于当前位置的key的话，将 e 指向该键值对
*如果此时桶中数据类型为 treeNode，使用红黑树进行插入
*如果是链表，则进行循环判断， 如果链表中包含该节点，跳出循环，如果链表中不包含该节点，则把该节点插入到链表末尾，同时，如果链表长度超过树化阈值（TREEIFY_THRESHOLD）且table容量超过最小树化容量（MIN_TREEIFY_CAPACITY），则进行链表转红黑树（由于table容量越小，越容易发生hash冲突，因此在table容量<MIN_TREEIFY_CAPACITY 的时候，如果链表长度>TREEIFY_THRESHOLD,会优先选择扩容，否则会进行链表转红黑树操作）
我们现在来看一下第一种情况：
table尚未初始化，对数据进行初始化
n = (tab = resize()).length;
可以看到嗷，table再未初始化的时候，会调用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;
//1、table已经初始化，且容量 > 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
}
//2、阈值大于0 threshold 使用 threshold 变量暂时保存 initialCapacity 参数的值
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
//3 threshold 和 table 皆未初始化情况，此处即为首次进行初始化
//也就在此处解释了构造方法中没有对threshold 和 初始容量进行赋值的问题
else { // zero initial threshold signifies using defaults
//如果阈值为零，表示使用默认的初始化值
//这种情况在调用无参构造的时候会出现，此时使用默认的容量和阈值
newCap = DEFAULT_INITIAL_CAPACITY;
//此处阈值即为 threshold=initialCapacity*loadFactor
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
// newThr 为 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;
//如果之前的数组桶里面已经存在数据，由于table容量发生变化，hash值也会发生变化，需要重新计算下标
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
//如果指定下标下有数据
if ((e = oldTab[j]) != null) {
//1、将指定下标数据置空
oldTab[j] = null;
//2、指定下标只有一个数据
if (e.next == null)
//直接将数据存放到新计算的hash值下标下
newTab[e.hash & (newCap - 1)] = e;
//3、如果是TreeNode数据结构
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
//4、对于链表，数据结构
else { // preserve order
//如果是链表，重新计算hash值，根据新的下标重新分组
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;
}
resize方法逻辑比较复杂，需要慢慢静下心来一步步的分析，但是经过总结，可以分为以下几步：
1、 首先先判断当前table是否进行过初始化，如果没有进行过初始化，此处就解决了调用无参构造方法时候，threshold和initialCapacity 未初始化的问题，如果已经初始化过了，则进行扩容，容量为原来的二倍
2、 扩容后创建新的table，并对所有的数据进行遍历
a:如果新计算的位置数据为空，则直接插入
b:如果新计算的位置为链表，则通过hash算法重新计算下标，对链表进行分组
c:如果是红黑树，则需要进行拆分操作
get方法
get方法应该对大部分小伙伴们来说，是很容易理解的，直接上源码：
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
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 &&
(first = tab[(n - 1) & hash]) != null) {
//1、根据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;
}
get方法相对于put来说，逻辑实在是简单太多了，一看就明白的那种
1、根据hash值查找到指定位置的数据
2、校验指定位置第一个节点的数据是key是否为传入的key，如果是直接返回第一个节点，否则继续查找第二个节点
3、如果数据是TreeNode（红黑树结构），直接通过红黑树查找节点数据并返回
4、如果是链表结构，循环查找所有节点，返回数据
5、如果没有找到符合要求的节点，返回null
在这个方法里面，需要注意的有两个地方：hash（key）和hash的取模运算 (n - 1) & hash
我们来看看hash（key）的源码：
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
这段代码叫做扰动函数，也是hashMap中的hash运算，主要分为下面几步：
1、 key.hashCode()，获取key的hashCode值，如果不进行重写的话返回的是根据内存地址得到的一个int值
2、 key.hashCode() 获取到的hashcode无符号右移16位并和元hashCode进行^ ，这样做的目的是为了让高位与低进行混合，让两者都参与运算，以便让hash值分布更加均匀
还有取模运算 (n - 1) & hash
first = tab[(n - 1) & hash])
hash算法中，为了使元素分布的更加均匀，很多都会使用取模运算，在hashMap中并没有使用hash%n这样进行取模运算，而是使用(n - 1) & hash进行代替，原因是在计算机中，&的效率要远高于%；需要注意的是，只有容量为2的n次幂的时候，(n - 1) & hash 才能等效hash%n，这也是hashMap 初始化初始容量时，无论传入任何值，都会通过tableSizeFor(int cap) 方法转化成2的n次幂的原因，这种巧妙的设计真的很令人惊叹；
至于为什么只有2的n次幂才能这样进行取模运算，这里就不再详细叙述了，有兴趣的可以自行去搜索相应的文章学习。
remove方法
最后，我们再来看一看remove方法
public V remove(Object key) {
Node<K,V> e;
return (e = removeNode(hash(key), key, null, false, true)) == null ?
null : e.value;
}
final Node<K,V> removeNode(int hash, Object key, Object value,
boolean matchValue, boolean movable) {
Node<K,V>[] tab; Node<K,V> p; int n, index;
//根据key和key的hash值，查找到对应的元素
if ((tab = table) != null && (n = tab.length) > 0 &&
(p = tab[index = (n - 1) & hash]) != null) {
Node<K,V> node = null, e; K k; V v;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
node = p;
else if ((e = p.next) != null) {
if (p instanceof TreeNode)
node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
else {
do {
if (e.hash == hash &&
((k = e.key) == key ||
(key != null && key.equals(k)))) {
node = e;
break;
}
p = e;
} while ((e = e.next) != null);
}
}
//如果查找的了元素node，移除即可
if (node != null && (!matchValue || (v = node.value) == value ||
(value != null && value.equals(v)))) {
//如果是TreeNode，通过树进行移除
if (node instanceof TreeNode)
((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
//如果是第一个节点，移除第一个节点，将index下标的位置指向第二个节点
else if (node == p)
tab[index] = node.next;
else
//如果不是链表的第一个节点，则移除该节点
p.next = node.next;
++modCount;
--size;
afterNodeRemoval(node);
return node;
}
}
return null;
}
从源码可以看出来，通过key找到需要移除的元素操作过程和get方法几乎一致，最后在查找到key对应的节点之后，根据节点的位置和类型，进行相应的移除操作就完成了，过程非常简单，就不再做多的说明了这里。
其他源码
到这里，hashMap的源码基本就解析完成了，其余的方法和源码逻辑相对非常简单，大部分还是使用上述代码来实现的，例如containsKey（jey），就是使用get方法中的getNode（）来判断的，这里就不一 一介绍了，小伙伴们可以自行去学习下。
另外，中间有很部分不影响逻辑理解的代码被一笔带过，比如 红黑树的转化，查找，删除等操作，有兴趣的可以参考之前的文章进行学习，Java集合源码分析（六）：红黑树，不过还有一些其他的特性需要自己多去了解一下。
四、总结
1、 HashMap 底层数据结构在JDK1.7之前是由数组+链表组成的，1.8之后又加入了红黑树；链表长度小于8的时候，发生Hash冲突后会增加链表的长度，当链表长度大于8的时候，会先判读数组的容量，如果容量小于64会先扩容（原因是数组容量越小，越容易发生碰撞，因此当容量过小的时候，首先要考虑的是扩容），如果容量大于64，则会将链表转化成红黑树以提升效率
2、 hashMap 的容量是2的n次幂，无论在初始化的时候传入的初始容量是多少，最终都会转化成2的n次幂，这样做的原因是为了在取模运算的时候可以使用&运算符，而不是%取余，可以极大的提上效率，同时也降低hash冲突
3、 HashMap是非线程安全的，在多线程的操作下会存在异常情况（如形成闭环（1.7），1.8已修复闭环问题，但仍不安全），可以使用HashTable或者ConcurrentHashMap进行代替
这一次的讨论就到这里，欢迎小伙伴们留言讨论！
763
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
