别人的文章写得很好，仅仅阅读一遍不如自己来写一遍，遂有了下文。
1. 写在前面
我的理解过程：
- 什么是哈希表
- HashMap的初始化
- 从put的实现了解HashMap都包含了哪些结构
- 从resize()方法了解如何进行扩容
2. 什么是哈希表
HashMap是通过哈希表来实现的。那么就要先明白哈希表是什么。
哈希表
维基百科-哈希表：散列表（Hash table，也叫哈希表），是根据键（Key）而直接访问在内存存储位置的数据结构。也就是说，它通过计算一个关于键值的函数，将所需查询的数据映射到表中一个位置来访问记录，这加快了查找速度。这个映射函数称做散列函数，存放记录的数组称做散列表。
哈希表将键值对<key , value>存放在数组中，键值对的key是无序的，所以使用某个函数f(key)来计算出在数组中的下标，再使用该数组下标来访问数组，从而提高性能。
而即使key不同，f(key)也可能相同。这种情况就叫哈希冲突。当f(key)的位置上已经有数据的情况下，就需要采取解决冲突的策略。常用的哈希冲突解决策略有两种：
- 开放寻址法
- 链接技术
开放寻址法，一般是在散列函数的基础上采取另一种算法，从而查找到下一个空的数组位置，再将新数据填充进去。从而有效利用原数组空间。
链接技术，HashMap采用的这种。链接技术是指，假如在某个位置产生了哈希冲突，就将新数据以链表的形式接在已有数据的后面。
而HashMap，具体实现就是哈希表。HashMap就可以简单地理解成数组加上链表的组合，至少Java SE7之前是这样的。JDK 8之后，假如了树结构，在链表长度大于8时，就会转换成红黑树。待会我们从源码去验证这一点。
3. HashMap的初始化
ps. 简书的Markdown代码高亮一片保护色，觉得还是很不适合。直接贴截图。
从下往上，三个构造器。initialCapacity是初始容量，loadFactor翻译过来叫负载因子。记住这两个变量。
可以了解一下，二者的默认值，如上。所以很多时候面试，问到HashMap初始大小，就是1 << 4 = 16。
但是这不足以让人信服，这只是设置了参数，我可没看到有什么传说中的数组实现。
找到put()方法：
再去找putVal()方法：
敏感地捕捉到红框内，table为空，就resize()。
确认一下，table确实是一个数组。这里又引出了Node<key,value>结构。存储键值对的类，了解一下。
只截取部分截图，可以看到，Node属性里面，除了key和value，还有hash和一个Node对象引用next。这一看就是链表的节点，是不是想起了学c语言时候的结构体。
那到底如何初始化，进入resize()方法：
默认情况下，红框处，使用了newCap新建了一个数组，这就是初始化了。记住Cap和Thr，一个是容量，一个是阈值。二者都是在resize()方法中计算，如何复制给类成员变量。
结论：默认HashMap初始容量大小16。
那么带参数的初始化呢？
带两个参数的HashMap的构造器如上图。两个参数，initialCapacity（初始容量）、loadFactor（负载因子）。
初始容量：
初始容量的意义十分明了。但是依旧作了一个转换tableSizeFor(initialCapacity)，该方法巧妙地保证了HashMap的容量是2的n次幂。
举个例子，比如17=16+1，换成2进制就是10001，结果就会变成11111+1=100000，就会=32。
按上图，最后n=1111 1111 1111 1111 再加1，就=1 0000 0000 0000 0000，相当于找到大于初始容量cap的最小的2次方。恰好是该方法注释的意思：
Returns a power of two size for the given target capacity.
负载因子
结论：当HashMap的元素数目大于当前容量乘以负载因子时，就会进行扩容。
resize()方法
恰好使用了一开始转换过后的初始容量来新建数组，同时还更新了阈值，使其等于容量乘以负载因子。
4. put方法的实现
put我们来分三种情况讨论。
（1）没有冲突
直接创建一个Node<key,value>实例，然后放入对应下标的数组。
（2）冲突，使用链表
冲突，就是存入一个键值对，但是发现数组上这个位置有数据了。
第一种情况是，要存的key，和已有的数据的key是一样的，那就用新的value覆盖旧的value。
还有第二种情况，就是key不同，但是计算出来的hash值一样。这种情况当然是存在的。
为什么不直接用Object自带的hashCode呢？
奈何英语太差，无法装逼。个人理解来就是，一般我们用的表都比较小，虽然最大支持30位二进制长度的表，但是一般没人用这么大的表。而Object自带的hashCode()方法给出的hash值是32位的，很可能高16位就用不到。只用低16位，或者很可能只用低4位（默认大小1 << 4 = 16）参与散列函数的计算就会很可能发生冲突。而Java工程师说他们在冲突比较多的时候使用了红黑树，所以使用最廉价的方式：将高16位和低16位异或后再来使用。
冲突之后，使用链表的方式：
遍历链表，找到next=null也就是结尾，然后把新的节点挂上去。
（3）使用红黑树
“1”处，看到节点都换成TreeNode<K,V>了，是TreeNode的话，直接新建TreeNode挂上去就好了。
“2”处，这是从链表到树的转换。
链表长度大于8的时候，就会整个儿换成树结构，Node变成TreeNode。
换成TreeNode之后，还会完成一次树的平衡操作，转换成红黑树。
这里有个重点，为什么使用红黑树？
我认为应该是链表的搜索性能低于树结构。链表想要得知一个key对应的元素，就需要遍历链表去查询；而使用树，比如HashMap里面的TreeNode类中的find方法如下：
只需要比较hash与节点的hash值的大小，这期间就可以省略掉很多不需要对比的节点。
又为何使用红黑树而不用AVL树呢？
为什么STL和linux都使用红黑树作为平衡树的实现？
可以看看知乎的这个回答。最近我也在看树这一块的知识，下一篇日记再来记录我的学习。
里面讲到AVL是严格平衡的二叉树，搜索性能最优，而插入删除的性能要低于红黑树。对于HashMap来说，插入删除当然也可能会是比较频繁的操作，所以综合考虑，红黑树比AVL树要更适用一点。
5. 扩容
扩容想知道些什么？
- 为什么需要扩容？
- 什么时候扩容，每次扩容多少？
- 扩容后有什么特殊处理吗？
（1）为什么需要扩容？
默认的HashMap的底层数组只有16大小。假如我们有100个数据需要存储，那就会造成至少82个数据在链表或者树结构上。假如需要使用这82个数据，就需要遍历树或者链表去查找数据，性能比直接通过数组下标查找要慢很多。所以需要扩容。
（2）那什么时候扩容以及扩容多少呢？
还记得一开始提到的loadFactor负载因子吗？
这是一个浮点数。在当前HashMap存储的键值对数量大于数组大小乘以负载因子的时候，就会进行扩容。
下面来验证一下：
如图，putVal()方法的结尾，++size > threshold 时，就会调用resize。threshold(阈值)，阈值何时赋值呢？
从绿框知道，阈值保证了都是newCap（新数组容量）的loadFactor倍。
细心的知道还有一个情况：
这种情况，在初始化创建数组的时候，依旧还是newCap（新数组容量）的loadFactor倍：
（3）扩容后的处理
直接去看代码，然后去理解代码为何这么写会比较难，毕竟读代码去和机器一样思考本身比较困难。所以换个方式，我们先知道逻辑，然后去验证代码是否像我们所想。
扩容之后，当然不能单纯地把数据赋值到新数组就好了。既然都有更大的空间了，就要把本来放在链表上的、放在树上的，都分配到新的更多的空间去。
那怎么分呢？旧的链表上的数据分到数组上新增出来的位置时，会不会占用掉不该占用的位置呢？
旧的数组里面的数据，放到新数组去，也应该遵循新数组新容量newCap的散列函数。
计算一个键值对所在的位置。
原来是：
index = (oldCap - 1) & hash
扩容后，newCap = oldCap << 1 = 2 * oldCap
index = (2 * oldCap - 1) & hash
&操作讲道理是二进制的。oldCap都是2的n次方，从二进制上讲，oldCap - 1和2*oldCap - 1只差了一位。比如：
8 - 1 = 7 = 111
2 * 8 - 1 = 15 = 1111
比如7的第4位就不参与计算，那就和用0111进行散列一样的效果。7和15的低3位和hash的&操作值都是一样的，都等于111 & hash，所以关键就在第4位。
用8 - > 16来举例子
所以链表或者树结构内的数据，只需要用第4位和hash值&操作一下，是0，hash的第4位也是0，算出来的值还是等于111 & hash，还是老位置；是1，表示hash第4位是1，结果就等于 1000 + 111 & hash（因为第4位的&操作已经确认是1了，所以是1000加上剩下3位的&操作），老位置再加上原数组长度。"第4位 & hash" 操作，也就是相当于直接用8 = 1000，来计算：1000 & hash，毕竟8的低3位都是0，不影响结果。
从8 -> 16 换成oldCap -> 2倍oldCap
再把例子换成oldCap来说，就是假如oldCap & hash = 0，就放在(oldCap - 1) & hash位置，是原位置；假如oldCap & hash = 1，就放在oldCap + (oldCap - 1) & hash，是老位置加上一个原数组长度。
理清楚了逻辑，我们就可以验证一下，HashMap是不是按这样的设想来做的。
链表形态的扩容
确实是oldCap & hash 的操作，逻辑上符合设想。
树结构的扩容
树结构单独封装了一个方法split():
这里面还有一个要点，分散后的链表，要是大于8，还是进行树的平衡操作；要是小于8就转换成链表。
先总结一下，现在都知道了些什么：
- 了解了HashMap是参考哈希表的设计方式，解决冲突的策略是链接技术
- HashMap构造实例的时候有个初始容量和负载因子的属性。
初始容量的用处了解了，负载因子还不了解。 - 了解了初始容量为什么都是2的n次方倍
- 了解了HashMap底层确实是个数组
- 了解了一开始是put的时候用初始容量新建的数组；了解了put一个元素，元素数量大于数组长度的时候就会进行扩容，扩容的大小是加倍；而扩容后，对于链表的处理是相当于重新按新容量进行哈希运算，将计算出来是新的位置的放到新位置。（这个依旧还是很难描述）
其实，了解数据结构，应该把其中的一个元素的结构也了解一下。到现在还没有去看HashMap中一个节点的结构：
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;
}
}
看代码知道，节点是Node<K,V>类，该类有hash、key、value、next 4个成员变量。next就是链表的下一个节点的意思了。
还可以看到Node重写了equals方法。Java越来越熟练之后呢，对于equals重写这样的处理就会更加敏感了。
再想一想，一般我们都是直接调用不带参数的构造器。那么HashMap的默认初始容量和负载因子值是多少呢？
看 这是默认的负载因子 = 0.75
这是初始化不带参的构造器。这里需要解释一下几个局部变量的意思。oldCap，newCap，cap相关就是容量，这就是旧新两个数组容量。oldThr、newThr，thr就是threshold，叫做阈值。一听名字就知道，这个阈值就是哈希表内元素超过这个阈值就需要进行扩容了。看最后一个else，不带参数的时候使用默认值，newCap容量就等于DEFAULT_INITIAL_CAPACITY=1 << 4 = 16。负载因子=DEFAULT_LOAD_FACTOR=0.75，那么阈值=16*0.75=12。
那么看一下之前的带参的构造器呢？
阈值=tableSizeFor(初始容量)
这里其实是没有涉及负载因子的。而假如用的是带两个参数的构造器，其中的负载因子根本就没有用到。
Java8之后，我们提到过，加入了红黑树的处理，那么什么时候会使用红黑树来处理呢？为什么要使用红黑树呢？
目光再次聚焦到putVal方法，聚焦到需要新增节点的时候。看到小红框上面一行就是newNode，新建了一个Node节点。但是小红框之内还是进行了特殊处理：
binCount是链表的节点数量，binCount大于TREEIFY_THRESHOLD-1时，这个值是多少：
是8。也就是链表长度大于7的时候，就要执行方法treeifyBin(tab, hash);，看看这个方法做了什么：
6. 总结
1. 什么是哈希表?
哈希表是利用数组存储键值对的一种方式，通过散列函数f(K)将存储位置下标和键(K)对应起来。
f(K)的计算结果相同时，叫做哈希冲突，可以通过开放地址法和链接技术两种策略解决。
开放地址法寻找空余的数组位置存储新值；链接技术采用链表方式将相同f(key)的键值对组成链表。
2. HashMap的初始化
默认是16位的数组，0.75的负载因子。可以自己传入数组初始容量和负载因子大小。
3. 从put的实现了解HashMap都包含了哪些结构
一般情况下是数组；发生哈希冲突后在相同的数组下标处形成链表；链表长度大于8的时候，将链表转换成红黑树。
4. 从resize()方法了解如何进行扩容
容量 = cap，负载因子 = loadFactor。当存储键值对数量大于cap*loadFactor时，进行扩容。每次扩容cap *= 2.
HashMap的优点
利用哈希表，通过散列函数计算出数组下标，然后访问相应数据。从而继承了数组通过下标访问数据性能很好的优点。
所以理论上，查询性能：数组 > HashMap > 链表
以上就是个人看了文章读了源码之后对HashMap的理解了，欢迎斧正补充。
参考：https://github.com/LRH1993/android_interview/blob/master/java/basis/hashmap.md
而且这个github地址里面还包含了很多很多的Java知识点，查漏补缺，醍醐灌顶。文章里面的图也非常形象，推荐阅读。
