HashMap是Java中经常使用到的一个类，它可以存储key-value键值对，通常用put(key.,value)来保存一个键值对，用get(key)来获取键key所对应的的值，以前也看过很多遍源码，但是一直没有好好总结一下，这里就总结一下，整理成博客，加深记忆。
概述
HashMap是一个hash表，实现了Map接口，这些实现提供了所有的映射操作并且允许null作为key或者value，HashMap大致与HashTable一样，除了它是非线程安全的并且允许null作为key/value。HashMap不保证映射的顺序，特别是它不保证这些顺序随着时间变化保持不变（当发生resize的时候顺序可能会发生变化）。
如果hash方法将元素正确的散列在数组中，那么就保证了基本操作（put/get）的时间复杂度是不变的。遍历集合所需要的时间与HashMap的容量(capacity)和他的实际大小(键值对的数量)是成正比的，因此，如果我们比较在意它遍历的效率，那么我们应该避免将他初始的容量设置的过高或者将它的负载因子设置的过低。
HashMap的效率与两个参数有关：initial capacity和oad factor，initial capacity就是HashMap创建时hash表的初始容量，load factor时衡量当实际大小为容量的多少倍时应该调整hash表的容量，通常是将hash表的容量扩大2倍，而扩容时会重新计算每个元素的索引并将它放到新的hash表中，这个过程是比较消耗性能的，所以如果我们事先知道我们需要存储多少个键值对，那么我们可以在创建HashMap的时候指定一个合适的initialCapacity来尽量避免频繁扩容。而load factor则会影响HashMap在时间和空间上的性能，过低则会造成内存的浪费，过高则会增加hash冲突的概率，从而降低时间性能。
内部常量
HashMap中定义了一些静态常量，我们先来看看它们都是什么含义
DEFAULT_INITIAL_CAPACITY：1<<4（16）hash表的默认容量，当未指定初始容量时会将hash表的容量设置为该值。
MAXIMUM_CAPACITY：1 << 30 hash表的最大容量。
DEFAULT_LOAD_FACTOR：0.75，默认的负载因子，提供了时间和空间性能上的一个平衡点。
TREEIFY_THRESHOLD：8，将链表转换为树的节点数量的阀值。
UNTREEIFY_THRESHOLD：6，将树转换为链表的节点数量的阀值。
MIN_TREEIFY_CAPACITY：64，将链表转换为树的hash表容量的阀值，如果hash表容量没有达到该阀值但是某一个节 点的链表的数量达到TREEIFY_THRESHOLD则会resize hash表而不会直接将链表转换为树。
常用方法
put
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
//当hash表为null或者长度为0时，resize。
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//i为计算出来的当前key对应的hash表中的索引，如果当前位置上的袁术为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的hash相同且两个key也相同，将当前元素p赋值给e
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
//如果当前节点是个树节点，将key-value生成树节点插入当前树
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
//当前节点是链表，遍历链表
for (int binCount = 0; ; ++binCount) {
//遍历到最后一个节点，未找到相同key的节点，生成一个新节点插入到链表末端
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
//如果当前链表的长度超出阀值，将链表转换为树
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
//若找到与当前key相同的节点，则赋值给e,跳出循环
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
//若e不是null，说明找到了与当前key相同的几点，那么直接替换该节点的value，并将旧的value返回
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
//若当前大小大于了需要扩容的阀值，扩容，threshold是每次resize时重新计算的一个全局变量。
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
我们可以看到它首先计算了key的hash值，为什么要通过这样来计算呢，那么我们首先要了解index的计算方法，index是通过hash&(n-1)来计算的，其中n为hash表的容量，它是2的幂，所以n-1的二进制所有位均为1，但是假设初始容量为16，那么n-1的二进制位1111，所以index由hash后四位确定，前面的对index的计算不起作用，因此，为了尽量避免hash冲突，就通过将key.hashCode()与它本身的无符号右移16位做异或运算来确定一个新的hash值，这样hashCode的前16位与后16位都参与运算，就降低了最后计算index相同的概率，保证了尽可能的散列分布。
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;
if (oldCap > 0) {
//若容量已经大于等于最大容量，将threshold设置为int最大值并直接返回旧的hash表
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
//若初始化时没有指定初始容量与负载因子并且这是第一次resize，将二者置为默认值
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;
//将原来hash表中的元素放入新的hash表
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
//若当前节点是单个的节点，那么计算它的index直接放入新的hash表即可
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;
//若当前节点为树节点，将树分割后放入新的hash表，具体的分割操作下面分析
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;
//将节点的hash与旧容量与运算为0的节点放入一个链表
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
//将hash与旧容量与运算不为0的节点放入另外一个链表
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
//将第一个链表放入新hash表的j位置
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
//将第二个链表放入新hash表的j——oldCap位置
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
链表的拆分
resize过程中拆分链表的时候分了两种情况，e.hash&oldCap是否为0，我们知道节点的index是由hash&(capacity-1)来确定的，由于容量为2的幂，所以它的二进制位100...00，而capacity-1的二进制位011...11，而新的capacity比旧的capacity多一位，所以newCapacity-1位111...11。
假设oldCapacity为10000(16)，则oldCapacity-1为01111，新的capacity为100000(32)，newCapacity-1为011111，
若hash&oldCapacity为0，则代表hash的倒数第5位为0，那么新的index = hash&(newCapacity-1) = hash&011111 与hash&001111时相等的，就是说扩容后的index与扩容前的index是一样的；
否则，位运算的结果就比老的index大2**4，也就是相当于向后平移了一个oldCapacity
所以一个链表中的元素在扩容后只有两种情况：要么index保持不变，要么index+oldCapacity，将这两种情况的元素组成新的链表放入对应的位置就完成了对链表的拆分和重新散列。
树的拆分
我们注意到书的拆分是调用的split方法
final void split(HashMap<K,V> map, Node<K,V>[] tab, int index, int bit) {
TreeNode<K,V> b = this;
// Relink into lo and hi lists, preserving order
TreeNode<K,V> loHead = null, loTail = null;
TreeNode<K,V> hiHead = null, hiTail = null;
int lc = 0, hc = 0;
for (TreeNode<K,V> e = b, next; e != null; e = next) {
next = (TreeNode<K,V>)e.next;
e.next = null;
if ((e.hash & bit) == 0) {
if ((e.prev = loTail) == null)
loHead = e;
else
loTail.next = e;
loTail = e;
++lc;
}
else {
if ((e.prev = hiTail) == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
++hc;
}
}
if (loHead != null) {
if (lc <= UNTREEIFY_THRESHOLD)
tab[index] = loHead.untreeify(map);
else {
tab[index] = loHead;
if (hiHead != null) // (else is already treeified)
loHead.treeify(tab);
}
}
if (hiHead != null) {
if (hc <= UNTREEIFY_THRESHOLD)
tab[index + bit] = hiHead.untreeify(map);
else {
tab[index + bit] = hiHead;
if (loHead != null)
hiHead.treeify(tab);
}
}
}
我们可以看到树的拆分其实与链表的拆分基本是一样的，都是分了两种情况，但是最后插入新的hash表后，多了两步操作：
- 判断这个链表的长度是否小于将树变为链表的阈值，如果小于，就将树转换为链表，
- 插入一个链表时如果另外一个链表不为空，代表这个树的结构已经发生变化，需要重新生成树，否则树的结构没有发生变化，不用处理
对树的插入和生成，涉及红黑树的自平衡，比较复杂，这里不做分析
至此，resize的流程就分析完了
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;
//(n - 1) & hash计算出index，并从hash表中拿到该位置上的节点
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
//如果该节点的key刚好与我们要找的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) {
//若当前节点为树节点，那么从树中查找相同key的节点
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;
}
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;
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;
//若当前节点的key与要删除的key相同，则将p赋值给node
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
node = p;
else if ((e = p.next) != null) {
//若当前节点为树节点，从树中找出key对应的节点赋值给node
if (p instanceof TreeNode)
node = ((TreeNode<K,V>)p).getTreeNode(hash, key);
else {
//若当前节点为链表节点，从树中找出key对应的节点赋值给node
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不为null，说明找到了key对应的节点
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)
//即链表的头节点为要删除的节点，直接将node的下一个节点放入数组
tab[index] = node.next;
else
//node为链表中的非头节点，此时p为node的前一个节点，直接将p的下一个节点赋值为node的下一个节点
p.next = node.next;
++modCount;
//大小减一
--size;
afterNodeRemoval(node);
return node;
}
}
return null;
}
remove方法还比较简单
总结
通过分析源码，我们知道HashMap内部的结构是数组+链表(红黑树)的一个结构。插入时当一个链表的长度达到阀值(8)时，则将链表转换为红黑树，红黑树是一种平衡二叉树，查找的时间复杂度为O(lgn)，当resize或者删除书中的元素时，若树的长度达到阀值(6)时，将红黑树转换为链表结构。关于红黑树的插入、删除、自平衡等操作这里没有展开分析。
HashMap中数组的长度总是2的幂，每次扩容都是扩大2倍，这是为了尽可能的避免hash冲突造成链表过长或者树的深度过大造成性能下降，因为2的幂-1的二进制总是低位全是1，做与运算对于尾数不同的hash值总是有不同的结果。
插入时：
-
当插入的key计算出来的index在数组中对应的元素为空时，直接将key-value生成一个Node放入数组。
-
若index对应的元素不为空
a、当前节点的key与插入的key相等时，替换节点的velue为新的value。
b、当前节点的key与插入的key不同时
(1)、当前节点为树节点，遍历树，若找到与key相同的节点，替换value，否则创建一个新的树节点插入合适的位置
(2)、当前节点为链表节点，遍历链表，若找到与key相同的节点，替换value，否则创建一个新的节点插入链表末端，若当前链表的长度超过阀值，转换为树
