HashMap简介
HashMap是实现map接口的一个重要实现类，在我们无论是日常还是面试，以及工作中都是一个经常用到角色。它的结构如下：
它的底层是用我们的哈希表和红黑树组成的。所以我们在学习HashMap底层原理的时候，需要有这两种数据结构的知识做铺垫，才能有更好的理解！
哈希表
散列表是由我们的数组和链表组成的，集成了两种数据结构的优点，我们先简单介绍一下这两种数据结构。
数组：数组存储区间是连续的，占用内存严重，故空间复杂度很大，但数组的二分查找时间复杂度很小，为 o（1），数组的特点：查找速度快、插入和删除效率低
链表：链表存储区间离散，占用内存比较宽松，故空间复杂度很小，但时间复杂度很大，为 o（n），链表的特点：查找速度慢、插入和删除效率高
哈希表：哈希表为每个对象计算出一个整数，称为哈希码。根据这些计算出来的整数(哈希码)保存在对应的位置上！如果遇到了哈希冲突，也就是同一个坑遇到了被占用的情况下，那么我们就会以链表的形式添加在后面。
红黑树
关于红黑树的知识点比较多，如果过多介绍红黑树的话，那么HashMap就不好介绍了。这里给上一个链接，一篇关于介绍红黑树非常好的文章。点击这里
源码解析
好了，开始解析我们的源码，通过解析源码更好的了解HashMap后，对那么常见的面试题也可以更加的吃透！
基本属性
首先就是介绍我们的HashMap的基本属性，对基本属性介绍完之后，对后面方法里使用时才不会迷惑
1、我们的默认的初始化的hashmap的容量，如果没有指定的话，就是我们的默认，1<<4就是16。
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
2、我们的hashmap最大容量，2的30次方。
static final int MAXIMUM_CAPACITY = 1 << 30;
3、默认的装载因子，0.75。有什么用呢？比如我们的容量现在是16，16*0.75=12，也就是说，当我们的实际容量到了12的时候，那么就会触发扩容机制，进行扩容！
static final float DEFAULT_LOAD_FACTOR = 0.75f;
4、我们知道哈希表是由数组和链表组成的，每一个位置都可以说是一个哈希桶。我们的哈希桶默认是链表，但是在JDK1.8之后我们的哈希桶中当有TREEIFY_THRESHOLD个节点的时候，也就是下面默认的8，我们桶中的链表会被转换为红黑树的结构。
static final int TREEIFY_THRESHOLD = 8;
5、与上面相同，不过不同的是，会将红黑树转换成链表。
static final int UNTREEIFY_THRESHOLD = 6;
6、当哈希桶的结构转换成树之前，还会有一次判断，只有键值对大于64才会转换！也就是我们下面定义的最小容量，这是为了避免哈希表建立初期多个键值对恰巧都在一个哈希桶上面，而导致了没必要的转换。
static final int MIN_TREEIFY_CAPACITY = 64;
7、内部结构静态内部类
8、其他成员变量
思考
这里同时引发了我们一些思考？为什么要将转换成树形结构的阈值设置为8呢？为什么不将转换成链表结构的阈值也设置为8呢？这里我们在最后面试题分析的时候统一进行回答！
构造方法
hashmap的构造方法有四个，不过我们重点介绍其中的一个，因为这一个理解了，其他的也不成问题。
//initialCapacity：初始大小
//loadFactor：装载因子
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);
}
总结了构造方法进行的操作：
- 首先是边界处理，如果初始大小小于0，抛异常。如果大于最大，那也只能赋予我们默认的最大值！如果装载因子小于0或者不是数字的话，抛异常！
- 然后就是进行我们的赋值，装载因子赋值，还有就是调用我们的
tableSizeFor来返回一个大于等于initialCapacity的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;
}
关于为什么做了位运算后可以返回大于等于它的二次幂，可以看一下这篇博文！点击跳转
这里的threshold也就是我们的阈值，当达到了这个阈值的时候我们会进行扩容！但是这里可能也会觉得疑惑，阈值不是容量*装载因子吗？不应该写成下面这样子吗？
this.threshold = tableSizeFor(initialCapacity) * this.loadFactor;
注意，在构造方法中，并没有对table这个成员变量进行初始化，table的初始化被推迟到了put方法中，在put方法中会用到resize()方法，然后对threshold重新计算。后面我们对方法分析时会谈到。
核心方法
关于hashmap和核心方法和考点，其实都集中在put方法和resize()方法，这也会是我们下面重点要介绍到的。
put方法
我们首先来看put方法
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
调用了我们的putval方法，参入了一个以key计算的哈希值，key，value，还有两个其他参数。在看putVal方法之前先来看一下hash方法，看看它是如何计算哈希值。
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
这是一个三目运算符，如果key不为null的话，返回我们的key的哈希值（低十六位）同时与高16位的异或运算。这一步的操作意义何为呢？我们先临时跳到putVal方法里面可以看到有这么一步操作
它将我们计算出来的哈希值，与我们的哈希表长度-1（为了获得）进行&运算，这是为了获取我的table下标。至于为什么-1呢？因为我们的长度都是2的整数次幂，转换成2进制也就是1000000....这种的形式，为了更好的随机，所有我们进行了-1操作，也就是变成11111111这种。因为&操作是都为1的时候才会为1，所以我的的1多的时候随机性才会更大，毕竟一个1能干过那么多的1吗？这是减少哈希冲突的第一步操作。举个例子说明一下：
比如我们的长度转换为2进制为 1000 0000 ，进行-1操作后就是 0111 1111
而这个时候我们原来的二进制数
1000 0000
&
0101 1011 = 0000 0000
与任何最高位不为1的数进行&运算，都会变成0，也就让我们的哈希冲突变大了!
而我们-1操作后
0111 1111
&
0101 1011 = 0101 1011
可以看出来，这样比原来的减少了很多的哈希冲突。
同时这也是为什么我们要让哈希的容量大小一定要为2的整数次幂
好了，我们要回答一下再上面那个问题了，为什么要返回低16位与高16位的异或作为key的最终hash值呢？同样举个例子演示一下这个流程：
假设length为8，HashMap的默认初始容量为16；
length = 8 ，（length-1） = 7 ， 转换二进制为111；
假设一个key的 hashcode = 78897121 ，转换二进制：100101100111101111111100001，与（length-1）& 运算如下
0000 0100 1011 0011 1101 1111 1110 0001
&运算
0000 0000 0000 0000 0000 0000 0000 0111
= 0000 0000 0000 0000 0000 0000 0000 0001 （就是十进制1，所以下标为1）
上述运算实质是：001 与 111 & 运算。也就是哈希值的低三位与length与运算。如果让哈希值的低三位更加随机，那么&结果就更加随机，就更能减少我们的哈希冲突了。如何让哈希值的低三位更加随机，那么就是让其与高位异或，所以我们才在返回的时候与高位异或了再返回。低位与高位异或的过程举个例子如下：
然后总结一下在与我们与哈希值进行运算的时候有这么一个规律：
当length=8时 下标运算结果取决于哈希值的低三位
当length=16时 下标运算结果取决于哈希值的低四位
当length=32时 下标运算结果取决于哈希值的低五位
当length=2的N次方， 下标运算结果取决于哈希值的低N位。
好了，我们继续回到我们的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为空的时候调用resize()进行扩容初始化
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))))
//hashcode和key相等，记录下原先的值
e = p;
//如果这个时候我们的哈希桶已经是红黑树结构，那么调用树的插入函数
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
//链表结构，同时我们的hashcode不相等
//找到与key相等的节点，更新value，退出循环
//如果没有找到与key相等的节点，在链表尾部插入，如果插入后节点数量大于
//我们变成红黑树的阈值，那么进行转换成红黑树
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;
//空实现，为LinkedHashMap预留
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
//键值对达到阈值，进行扩容
if (++size > threshold)
resize();
//空实现，为LinkedHashMap预留
afterNodeInsertion(evict);
return null;
}
resize()方法
我们在上面不管是源码分析还是在哪分析，都说到了我们的resize()方法，下面我们将正式开始讲到
final Node<K,V>[] resize() {
//原table数组赋值
Node<K,V>[] oldTab = table;
//如果原数组为null，那么原数组长度为0
int oldCap = (oldTab == null) ? 0 : oldTab.length;
//赋值阈值
int oldThr = threshold;
//newCap 新数组长度
//newThr 下次扩容的阈值
int newCap, newThr = 0;
// 1. 如果原数组长度大于0
if (oldCap > 0) {
//如果大于最大长度1 << 30 = 1073741824，那么阈值赋值为Integer.MAX_VALUE后直接返回
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
// 2. 如果原数组长度的2倍小于最大长度，并且原数组长度大于默认长度16，那么新阈值为原阈值的2倍
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
// 3. 如果原数组长度等于0，但原阈值大于0，那么新的数组长度赋值为原阈值大小
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
else { // zero initial threshold signifies using defaults
// 4. 如果原数组长度为0，阈值为0，那么新数组长度，新阈值都初始化为默认值
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
// 5.如果新的阈值等于0
if (newThr == 0) {
//计算临时阈值
float ft = (float)newCap * loadFactor;
//新数组长度小于最大长度，临时阈值也小于最大长度，新阈值为临时阈值，否则是Integer.MAX_VALUE
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
//计算出来的新阈值赋值给对象的阈值
threshold = newThr;
@SuppressWarnings({"rawtypes","unchecked"})
//用新计算的数组长度新建一个Node数组，并赋值给对象的table
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
//后面是copy数组和链表数据逻辑
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;
}
这个时候我们以最初的三种构造方法来模拟一下流程。上面每一个扩容情况都标注了记号
//①
Map<String, String> map = new HashMap<>();
map.put("1", "1");
//②
Map<String, String> map1 = new HashMap<>(2);
map1.put("2", "2");
//③
Map<String, String> map2 = new HashMap<>(2, 0.5f);
map2.put("3", "3");
① 没有设置initialCapacity，也没有设置负载因子，第一次put的时候会触发扩容。第一次的时候，数组长度为默认值16，阈值为160.75=12，走的
代码4逻辑，等到数组长度超过阈值12后，触发第二次扩容，此时table数组，和threshold都不为0，即oldTab、oldCap、oldThr都不为0，先走代码1，如果oldCap长度的2倍没有超过最大容量，并且oldCap 长度大于等于 默认容量16，那么下次扩容的阈值 变为oldThr大小的两倍即 12 2 = 24，newThr = 24，newCap=32② 设置了initialCapacity，没有设置负载因子，此时hashMap使用默认负载因子0.75，本实例设置的初始容量为2，通过计算阈值为2，第一次put的时候由于还没初始化table数组，因此触发第一次扩容。此时oldCap为0，oldThr为2，走
代码3，确定这次扩容的新数组大小为2，此时还没有确定newThr 下次扩容的大小，于是进入代码5确定newThr为 2 0.75 = 1.5 取整 1 ，及下次扩容阈值为1。当数组已有元素大于阈值及1时，触发第二次扩容，此时oldCap为1，oldThr为1，走代码1newCap = oldCap << 1 结果为 4 小于最大容量， 但oldCap 小于hashMap默认大小16，结果为false，跳出判断，此时由于newThr等于0，进入代码5，确定newThr为 4 0.75 = 3，下次扩容阈值为3③ 设置了initialCapacity=2，负载因子为0.5，通过tableSizeFor计算阈值为2，第一次put的时候，进行扩容，此时oldCap为2，oldThr为2，进入
代码1，同实例②，newCap = oldCap << 1 结果为 4 小于最大容量， 但oldCap 小于hashMap默认大小16，结果为false，跳出判断，进入代码5，确定newThr为 4 * 0.5 = 2,下次扩容阈值为2
get()方法
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
获取了我们的key的hashcode然后作为参数传入getNode方法中！
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) {
//如果刚好在哈希桶的第一个节点上，返回
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;
}
remove方法
public V remove(Object key) {
Node<K,V> e;
return (e = removeNode(hash(key), key, null, false, true)) == null ?
null : e.value;
}
首先是计算出我们的hash，然后调用removeNode方法来移除
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;
//我们的哈希桶不为空，同时要映射的哈希值也在
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 {
//对链表进行查找key
do {
if (e.hash == hash &&
((k = e.key) == key ||
(key != null && key.equals(k)))) {
node = e;
break;
}
p = e;
} while ((e = e.next) != null);
}
}
//找到了之后就去删除，分红黑树，桶的首位，链表中，
if (node != null && (!matchValue || (v = node.value) == value ||
(value != null && value.equals(v)))) {
//红黑树，调用树删除节点的方法
if (node instanceof TreeNode)
((TreeNode<K,V>)node).removeTreeNode(this, tab, movable);
//在桶首位，直接将下一个节点赋值给首位
else if (node == p)
tab[index] = node.next;
//在链表中，将下一个结点赋值给前一个节点的下一个节点，删除自我
else
p.next = node.next;
++modCount;
--size;
afterNodeRemoval(node);
return node;
}
}
return null;
}
总结
扩容是一个特别耗性能的操作，所以当我们在使用 HashMap，正确估算 map 的大小，初始化的时候给一个大致的数值，避免 map 进行频繁的扩容。
负载因子 loadFactor 是可以修改的，也可以大于1，但是建议不要轻易修改，除非情况特殊。
HashMap 是非线程安全的，不要在并发的情况下使用 HashMap，建议使用 ConcurrentHashMap！
面试题分析
关于HashMap的源码就分析这些，因为这些足够我们去了解它的一些基本特性和常见面试足够用了。下面我收集了一些面试题和我们上面的留下的思考题进行分析！
1、为什么要将转换成树形结构的阈值设置为8呢？为什么不将转换成链表结构的阈值也设置为8呢？
当初始阈值为8时，链表的长度达到8的概率变的很小，如果再大概率减小的并不明显
树结构查找的时间复杂度是O(log(n))，而链表的时间复杂度是O(n)，当阈值为8时，long8 = 3，相比链表更快，但树结构比链表占用的空间更多，所以这是一种时间和空间的平衡
至于为什么不将转换链表的阈值也设置为8，是因为如果两个值太接近的话，就会造成频繁的转换，导致我们的时间复杂度变高。而在6是经过计算后最合适的数值
2、HashMap 为什么不用平衡树，而用红黑树？
这一题应该归类与数据结构了，不过这里同样给出分析
红黑树也是一种平衡树，但不是严格平衡，平衡树是左右子树高度差不超过1，红黑树可以是2倍
红黑树在插入、删除的时候旋转的概率比平衡树低很多，效率比平衡树高
查找时间复杂度都维持在O(logN)，具体的还望查看红黑树的特性，上面最开始也给了一篇关于红黑树的介绍。
3、HashMap在并发下会产生什么问题？有什么替代方案?
HashMap并发下产生问题：
- 由于在发生hash冲突，插入链表的时候，多线程会造成环链，再get的时候变成死循环，Map.size()不准确，数据丢失。关于为什么会造成环链的话，可以看这里！
- 在多线程情况下进行put的操作时候，会造成我们的数据丢失！
替代方案：
- HashTable: 通过synchronized来修饰，效率低，多线程put的时候，只能有一个线程成功，其他线程都处于阻塞状态
- ConcurrentHashMap：
1.7 采用锁分段技术提高并发访问率
1.8 数据依旧是分段存储，但锁采用了synchronized - 使用我们的Collctions下面的SynchronizedMap，但其实也就是在方法前面加了synchronized来修饰，缺点如HashTable。
4、HashMap中的key可以是任何对象或数据类型吗？
可以是null，但不能是可变对象，如果是可变对象，对象中的属性改变，则对象的HashCode也相应改变，导致下次无法查找到已存在Map中的数据
如果要可变对象当着键，必须保证其HashCode在成员属性改变的时候保持不变
5、为什么不直接将key作为哈希值而是与高16位做异或运算？
这个我们在上面说过了，还用图和样例解释，是为了更好的随机性，解决哈希碰撞。
6、关于更多的面试题
这里提供了一篇关于面试题挺多的博文，通过阅读源码，里面大部分的面试题都可以解答了！
HashMap与HashTable有什么不同？
因为HashTable和HashMap很是类似，就跟我们的Vector与ArrayList的关系一样。提供了线程安全的解决方案，所有我们在这里通过区别，就相当与对HashTable进行了源码分析！
从存储结构和实现来讲基本上都是相同的。
它和HashMap的最大的不同是它是线程安全的，另外它不允许key和value为null。
Hashtable是个过时的集合类，不建议在新代码中使用，不需要线程安全的场合可以用HashMap替换，需要线程安全的场合可以用ConcurrentHashMap替换或者Collections的synchronizedMap方法使HashMap具有线程安全的能力。
| 不同点 | HashMap | HashTable |
|---|---|---|
| 数据结构 | 数组+链表+红黑树 | 数组+链表 |
| 继承的类不同 | 继承AbstractMap | 继承Dictionary |
| 是否线程安全 | 否 | 是 |
| 性能高低 | 高 | 低 |
| 默认初始化容量 | 16 | 11 |
| 扩容方式不同 | 原始容量*2 | 原始容量*2+1 |
| 底层数组的容量为2的整数次幂 | 要求为2的整数次幂 | 不要求 |
| 确认key在数组中的索引的方法不同 | i = (n - 1) & hash; | index = (hash & 0x7FFFFFFF) % tab.length; |
| 遍历方式 | Iterator(迭代器) | Iterator(迭代器)和Enumeration(枚举器) |
| Iterator遍历数组顺序 | 索引从小到大 | 索引从大到小 |
参考资料
公众号《Java3y》文章
知乎专栏《Java那些事儿》
