一、 哈希函数理解
如果我们自己要设计一个数据结构，首要任务是查询快，其次增删改快，怎么设计呢？
我们知道，数据结构的物理存储结构只有两种：顺序存储结构和链式存储结构（像栈，队列，树，图等是从逻辑结构去抽象的，映射到内存中，也这两种物理组织形式），所以我们要自己设计一个容器装数据，也得从这两个结构下手：
- 顺序存储，这个代表的对象就是数组，内存直接分配一块连续的空间，在此基础上，只要你知道相对于数组第一个位置的下标，就能快速访问到想要的数据，非常快（例如：a[3]=5；），时间复杂度O（1），但是给定一个值让你找，那也只能遍历了，时间复杂度是O（n）。数组还有有个弱点，就是当你要在已有数据中间新增或者删除的时候，都会导致后续的元素平移，耗时，这不符合我们的预期。
- 链式存储结构，其内存散碎在各处，每个元素通过存储自己前后邻居的位置，而你只知道住在第一家的位置，你想找任何一个人，唯一的方法就是一个一个问，这样查询的效率极低，时间复杂度是O（n），优势是你想插队或者删除一个，只要通知它左右邻居就可以，很方便。
因为我们首要任务是查询快，而顺序结构特点就是查询快，只要你能知道它的位置就能直接访问它的元素，所以主体我们选择顺序结构，但是实际工作中，我们都是直接按值查找，那不是没快么，如果有个算法，能根据值算出元素在数组中的位置就好了，这个算法其实就是哈希算法。
哈希算法：这个算法通俗来说就是把你要查找的内容翻译成位置。比如我们要新增或查找某个元素，我们通过把当前元素的关键字 通过某个函数映射到数组中的某个位置，通过数组下标一次定位就可完成操作。这个函数可以简单描述为：存储位置 = f(关键字) ，这个函数f一般称为哈希函数，这个函数的设计好坏会直接影响到哈希表的优劣。
整个过程有点像推币机：
只不过中间算法部分，被替换成了哈希算法，它会根据小球“key”的哈希，决定你在数组的哪个槽里。（如果按照当前算法，最后小球的落点是符合正态分布的），好的哈希算法，会精良把小球分散开来，不让他们落入同一个槽里，如果不幸落入同一个槽，那这就是哈希碰撞，也叫哈希冲突。
有了碰撞怎么处理呢，毕竟不能让一堆数据放到同一个地址里，处理哈希碰撞的方法有：
开放地址法：发生冲突，继续寻找下一块未被占用的存储地址。
再散列函数法：发生冲突就换一个散列函数，总有一个不碰撞的。
公共溢出区法：即为所有冲突的关键字建立一个公共的溢出区来存放，在查找时，对给定值通过散列函数计算出散列地址后，先与基本表的相应位置进行比对，如果相等，则查找成功，如果不相等，则到溢出表去进行顺序查找。
链地址法：把后续算出来同一个地址的小球（元素）用链表串起来，为什么用链表呢，因为方便增减，但是我们前面说过了，链表只能遍历查，所以要求这个链子不能太长，最多7个（jkd1.8），再长就转成红黑树。这个就是HashMap采用的方法。
二、 HashMap解析
1. 构造函数
HashMap的在new的时候，并不会初始化它内部的Node对象数组，只会设置数组的容量和扩容阈值（扩容阈值是指一旦HashMap装满到一定程度，会触发自动扩容，一般扩容成当前容量的两倍）。
HashMap有以下4个构造函数
//负载系数
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//1 不带任何参数的，就是日常最多用到的，它只设置了一下阈值负载系数，也就是最大容量的75%
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
//2 传入初始化容量的，阈值负载系数还是用默认的
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
//3 传入初始化容量和阈值负载系数
public HashMap(int initialCapacity, float loadFactor) {
//如果传入的容量大于最大容量了，就默认使用最大容量。
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
this.loadFactor = loadFactor;
//下次表容量到达threshold值时，触发扩容。
this.threshold = tableSizeFor(initialCapacity);
}
//4 根据传入的Map来构造一个新的HashMap，老Map中的值会赋给新的HashMap中。
public HashMap(Map<? extends K, ? extends V> m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m, false);
}
tableSizeFor方法，这个方法单独列出来讲，是因为涉及到后续我之前没有理解的点，那就是这个类中的threshold到底是什么。
官方给的doc直译是：返回给定目标容量的两个大小的幂。
实际测试的是返回一个比给定值大的最小的二的次幂，比如你传5或者6、7，它就返回8，你传9、10、11、12、13、14、15，它就返回16。
在我实际的测试中，如果你初始化的时候，给定的容量不是2的整次幂，那么你新表的容量，就是从这个函数中来的，后续扩容的地方会详细讲为什么，这里直接说结论，如果你初始化容量是2的整次幂，那么threshold就是扩容阈值，如果不是，则是表容量。
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;
}
2. put方法
如果你第一次使用put，那就初始化数组并存值，如果之前初始化过，则正常存值。
也可以理解成往HashMap里放小球，一个小球对于HaspMap来说就是一个Node对象，Node对象就是我们使用的key-value格式。
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> next;
//这里可以看出，Node除了能存储Key-Vaule以外，还能组成一个单向的链表。
Node(int hash, K key, V value, Node<K,V> next) {
...
}
...
}
put方法源码：
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
参数解析：
hash:key值算出来的hash值，这个就是我们上面说的，算位置。
key:这个就是存入数据的Key。
value:存入数据的value。
onlyIfAbsent：如果为true，则不更改现有值。（不知道干啥的）
evict：如果为false，则表处于创建模式。（不知道干啥的）
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
//判断当前map中的Node数组是不是空的，如果是空的，调用resize()方法，这个方法的作用是将Node数组大小初始化或加倍，这里用到的就是初始化。无论是不是第一次初始化，都要把最终数组也就是tab的长度赋值给n。
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
// (n - 1) & hash 这就是计算位置的算法，找到新存入Node的key的hash值，与数组长度-1相与，然后判断这个位置是否有值了。
if ((p = tab[i = (n - 1) & hash]) == null)
//如果没有值，说明这个位置是空的，那直接new一个Node放到这个位置上。
tab[i] = newNode(hash, key, value, null);
else {
//如果不为空，说明碰撞了，在if中已经把这个位置已经存在的原有元素取出来，赋值给p，记住这个p是原来就有的节点啊。
Node<K,V> e; K k;
//判断p是不是就是新存入的这个元素，也就是同一个key，如果是的话就直接覆盖。
if (p.hash == hash &&((k = p.key) == key || (key != null && key.equals(k))))
e = p;
else if (p instanceof TreeNode)
//如果不是，则判断p是不是一棵树的节点，如果是的话，那就走新增树节点的逻辑，把新加入的拼到红黑树上。
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);
//TREEIFY_THRESHOLD是8，这里就是上文所说的，如果链表太长，会影响后续查询效率，只要大于等于8，就把链表转成红黑树。
//这里有个迷惑人的点，TREEIFY_THRESHOLD - 1不是等于7么，为什么是大于8呢，因为这里的binCount是从0开始的，是元素开始遍历的位置，不是数组长度，数组长度应该是binCount+1，所以这个判断应该是binCount+1 >= TREEIFY_THRESHOLD。
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;
//这一步在HashMap没有实现，是为了LinkHashMap用的，为的是使用LRU算法。
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
//如果没有碰撞，数据存入Node数组中了，那把数组size加一，然后跟阈值相比，HashMap默认阈值是最大size的四分之三，如果超了，触发扩容机制。
if (++size > threshold)
resize();
//这一步在HashMap没有实现，是为了LinkHashMap用的，为的是使用LRU算法。
afterNodeInsertion(evict);
return null;
}
扩容resize()：将Node对象数组的大小初始化或加倍。如果数组为空，则根据字段阈值中保留的初始容量目初始化数组。否则，使用二的整数次幂扩容（一般都是现有基础的两倍），每个桶中的元素必须保持在相同的索引中，或者在新数组中以二次幂偏移量移动。
//扩容逻辑太长了，这里为了方便使用简化版本
final Node<K,V>[] resize() {
//现有表
Node<K,V>[] oldTab = table;
//现有表容量
int oldCap = (oldTab == null) ? 0 : oldTab.length;
//threshold：触发扩容的阈值
int oldThr = threshold;
//newCap新表的容量，newThr新表的阈值
int newCap, newThr = 0;
//a1.先判断老表是否有值，如果有，则容量和阈值都2倍扩容（oldCap << 1的意思是，原有值向左边移动一位，因为是二进制，所以左移一位就是乘以2，比如十进制左移两位就是，23<<2 = 2300）
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
}
//a2.这种情况就是new的时候，给定的初始化容量不是2的整次幂，则oldThr就会自动算出大于你规定的容量最近的2的整次幂，然后作为新表容量。
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
//a3.这种情况就是上面说的第一次调用put的情况，都按照默认值初始化新表
else { // zero initial threshold signifies using defaults
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
//a2那种情况下，给新表计算一个新的阈值
if (newThr == 0) {
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
//到这一步，threshold算是回归他的老本行了，扩容阈值
threshold = newThr;
@SuppressWarnings({"rawtypes","unchecked"})
//根据新容量构件一个新的表（Node对象数组）
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 { // 如果是链表，走链表的迁移
...
}
}
}
}
return newTab;
}
3. get方法
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
//通过key值和key值的hash值获取对应元素
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
//这里要确定查询的表不为空，并且hash值对应的位置不能为空
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);
do {
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}
4. 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;
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);
}
}
//这里就是根据不同数据结构，移除对应的元素
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;
}