HashMap算是日常开发中最长用的类之一了，我们应该了解它的结构跟算法：
参考文章：
数据结构中有数组核链表来实现对数据的存储，但这两者基本上是两个极端。
数组：存储区间是连续的，占用内存严重，故空间复杂的很大。但数组的二分查找时间复杂度小，为O(1)；数组的特点是：寻址容易，插入和删除困难；
链表：存储区间离散，占用内存比较宽松，故空间复杂度很小，但时间复杂度很大，达O（N）。链表的特点是：寻址困难，插入和删除容易。
哈希表：那么我们能不能综合两者的特性，做出一种寻址容易，插入删除也容易的数据结构？答案是肯定的，这就是我们要提起的哈希表。哈希表（(Hash table）既满足了数据的查找方便，同时不占用太多的内容空间，使用也十分方便。
哈希表有多种不同的实现方法，我接下来解释的是最常用的一种方法—— 拉链法，我们可以理解为“链表的数组” ，如图：
从上图我们可以发现哈希表是由数组+链表组成的，一个长度为16的数组中，每个元素存储的是一个链表的头结点。那么这些元素是按照什么样的规则存储到数组中呢。一般情况是通过hash(key)%len获得，也就是元素的key的哈希值对数组长度取模得到。比如上述哈希表中，12%16=12,28%16=12,108%16=12,140%16=12。所以12、28、108以及140都存储在数组下标为12的位置。
HashMap其实也是一个线性的数组实现的,所以可以理解为其存储数据的容器就是一个线性数组。这可能让我们很不解，一个线性的数组怎么实现按键值对来存取数据呢？这里HashMap有做一些处理。
首先HashMap里面实现一个静态内部类Entry(jdk8改为用Node了)，其重要的属性有 key , value, next，从属性key,value我们就能很明显的看出来Entry就是HashMap键值对实现的一个基础bean，我们上面说到HashMap的基础就是一个线性数组，这个数组就是Entry[](jdk8就是Node[])，Map里面的内容都保存在Entry[]里面。
------------------------------------------------------------
HashMap的hash方法：
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
所谓的高位参与运算，就是key的hashCode异或hashCode的高16位。
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) // entry数组为空，new HashMap的时候，并没有初始化数组
n = (tab = resize()).length; //初始化数组，稍后看resize()实现
if ((p = tab[i = (n - 1) & hash]) == null) //分配到的数组位置为null，这里一个很巧妙的操作，没有用取模%运算，而是这个位与，效率更高而且正好这里等于取模
tab[i] = newNode(hash, key, value, null);
else {//分配到的位置不是null的情况，要遍历链表
Node<K,V> e; K k;
if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) // key跟链表第一个元素的key相同，这里比较的是hashcode跟equals，从本方法以及Node的构造方法来看，Node的hash就是其中键的hash值
e = p; // 注意，这里找到后并没有修改节点的值，节点的值是在后边修改的
else if (p instanceof TreeNode) //是treenode，jdk8在链表长度超过8后将node改为红黑树进行优化
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); // 结合Node的构造方法，node的hash就是此处的hash
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)))) //链表有节点的hash跟新元素相同并且equals判断也相等
break; //找到了，终止循环
p = e; // 注意，这句不在if范围内，仅仅在for循环内而已，所以如果已经有对应节点已经有oldValue的情况下，并没有修改原来的值，修改的操作在后边
}
}
if (e != null) { // existing mapping for key //有oldValue的情况，e就是旧节点
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null) // 允许重写原来值，或者原来的值为null，注意，onlyIfAbsent，这个属性hashmap实际没用，一直是默认false，也就一直默认覆盖原来的值
e.value = value;
afterNodeAccess(e); // 值更新之后的操作，hashmap中此方法为空，无任何操作，该方法以及后边的afterNodeInsertion()都是给LinkedHashMap用的。
return oldValue;
}
}
++modCount; // 修改计数器，其实只有新增才修改了此值，覆盖原来值的操作，因为提前return 了，此值没有改变
if (++size > threshold) // hashMpa的容量达到了阈值
resize();
afterNodeInsertion(evict);
return null;
}
// Callbacks to allow LinkedHashMap post-actions
void afterNodeAccess(Node<K,V> p) { }
void afterNodeInsertion(boolean evict) { }
void afterNodeRemoval(Node<K,V> p) { }
链表的实现类Node：
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) { // 节点的hash就是所给元素的hash
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) // 地址相等----------其实这个值不一定是内存地址，不同虚拟机实现不同，sun貌似是地址的一个hash值
return true;
if (o instanceof Map.Entry) {
Map.Entry<?,?> e = (Map.Entry<?,?>)o;
if (Objects.equals(key, e.getKey()) && Objects.equals(value, e.getValue())) // 键跟值的equals都相等
return true;
}
return false;
}
}
非常重要的resize() 方法：
/** * Initializes or doubles table size. If null, allocates in accord with initial capacity target held in field threshold. * Otherwise, because we are using power-of-two expansion, the elements from each bin must either stay at same index, or move * with a power of two offset in the new table. * @return the table */
大概意思是说，该方法用来初始化table或者使table的容量翻倍，如果原来table为空，则根据初始化参数进行初始化；否则，因为我们采用2的幂方案，每个链表的元素应该在容量翻倍后仍然位于新table的相同下标下或者移动到二倍下标位置。
说明：这个地方jdk8比jdk7做了优化，如果不了解其原理的话，读起来非常费解。jdk7的时候，resize就是把数组扩展为2倍，遍历每个数组中的链表，
进行重新hash取模找位置，而且链表元素添最先加的在后边，最后添加的在前边；jdk8对此做了优化，仍然扩展为2倍，遍历链表，但没有简单的进行hash取模找位置，
而是采用了查看参与计算的新的一位的hash的值是1还是0的办法，是0则位置不变，是1则位置变为原index+size，而且新添加的元素放在了链表的尾部。
其原理详解，摘抄自美团：https://tech.meituan.com/java-hashmap.html，写的非常好：
下面举个例子说明下扩容过程（jdk7）。假设了我们的hash算法就是简单的用key mod 一下表的大小（也就是数组的长度）。其中的哈希桶数组table的size=2， 所以key = 3、7、5，put顺序依次为 5、7、3。在mod 2以后都冲突在table[1]这里了。这里假设负载因子 loadFactor=1，即当键值对的实际大小size 大于 table的实际大小时进行扩容。接下来的三个步骤是哈希桶数组 resize成4，然后所有的Node重新rehash的过程。
下面我们讲解下JDK1.8做了哪些优化。经过观测可以发现，我们使用的是2次幂的扩展(指长度扩为原来2倍)，所以，元素的位置要么是在原位置，要么是在原位置再移动2次幂的位置。看下图可以明白这句话的意思，n为table的长度，图（a）表示扩容前的key1和key2两种key确定索引位置的示例，图（b）表示扩容后key1和key2两种key确定索引位置的示例，其中hash1是key1对应的哈希与高位运算结果。
元素在重新计算hash之后，因为n变为2倍，那么n-1的mask范围在高位多1bit(红色)，因此新的index就会发生这样的变化：
因此，我们在扩充HashMap的时候，不需要像JDK1.7的实现那样重新计算hash，只需要看看原来的hash值新增的那个bit是1还是0就好了，是0的话索引没变，是1的话索引变成“原索引+oldCap”，可以看看下图为16扩充为32的resize示意图：
这个设计确实非常的巧妙，既省去了重新计算hash值的时间，而且同时，由于新增的1bit是0还是1可以认为是随机的，因此resize的过程，均匀的把之前的冲突的节点分散到新的bucket了，当然图中显示的每隔一个分到相同下标，实际其实是无规律的。这一块就是JDK1.8新增的优化点。有一点注意区别，JDK1.7中rehash的时候，旧链表迁移新链表的时候，如果在新表的数组索引位置相同，则链表元素会倒置，但是从上图可以看出，JDK1.8不会倒置。
jdk8源码：
1. final Node<K,V>[] resize() {
2. Node<K,V>[] oldTab = table; //老的数组，也就是所谓的桶
3. int oldCap = (oldTab == null) ? 0 : oldTab.length; // 老的容量
4. int oldThr = threshold; // 阈值
5. int newCap, newThr = 0;
6. if (oldCap > 0) { // 老的容量>0，说明map里已经有元素了
7. if (oldCap >= MAXIMUM_CAPACITY) { // 老的容量已经很大了，直接把阈值扩展到最大，不再容量翻倍了，太费劲了，而且效率提升有限，此时容量2的29次方，大概在3亿
8. threshold = Integer.MAX_VALUE;
9. return oldTab;
10. }
11. else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY && oldCap >= DEFAULT_INITIAL_CAPACITY) //老容量在2<<<28的时候还能翻倍，到了2<<<29就不翻倍了，凑合着用吧
12. newThr = oldThr << 1; // double threshold
13. }
14. else if (oldThr > 0) // initial capacity was placed in threshold // 老容量==0，阈值>0,说明调用了new HashMap(容量=0，加载因子);
15. newCap = oldThr;
16. else { // zero initial threshold signifies using defaults //都是用默认值
17. newCap = DEFAULT_INITIAL_CAPACITY; // 默认1<<<4 = 16
18. newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY); //默认16*0.75=12
19. }
20. if (newThr == 0) { //上来就new HashMap(容量大于2<<<29);没有指定加载因子的情况，自己计算阈值
21. float ft = (float)newCap * loadFactor;
22. newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
23. (int)ft : Integer.MAX_VALUE);
24. }
25. threshold = newThr;
26. Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
27. table = newTab;
28. if (oldTab != null) {
29. for (int j = 0; j < oldCap; ++j) { // 重点来了，迁移老数组进新数组
30. Node<K,V> e;
31. if ((e = oldTab[j]) != null) {
32. oldTab[j] = null;
33. if (e.next == null) //原数组j下标下，就一个元素
34. newTab[e.hash & (newCap - 1)] = e; //直接快速位与取模，找下标
35. else if (e instanceof TreeNode) //是红黑树节点
36. ((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
37. else { // preserve order
38. Node<K,V> loHead = null, loTail = null; //这里分别lowHead tail跟highHead tail两个对象，稍后分析为啥这么写
39. Node<K,V> hiHead = null, hiTail = null;
40. Node<K,V> next;
41. do { // j下标下有好多个链表的情况
42. next = e.next;
43. if ((e.hash & oldCap) == 0) {//hash中参与计算的新一位为0，下标不变; 计算方式参照上方图解；
44. if (loTail == null)
45. loHead = e;
46. else
47. loTail.next = e;
48. loTail = e;
49. }
50. else { // hash中参与计算的新一位为1，下标变为 原容量+原下标，不用重新计算了，省事儿，就是优化在这里了(实际这一步也是计算了，只是计算比原来简单了)
51. if (hiTail == null)
52. hiHead = e;
53. else
54. hiTail.next = e;
55. hiTail = e;
56. }
57. } while ((e = next) != null);// 遍历下一个元素
58. if (loTail != null) { // 设置下标，放入新数组
59. loTail.next = null;
60. newTab[j] = loHead;
61. }
62. if (hiTail != null) { // 设置下标，放入新数组
63. hiTail.next = null;
64. newTab[j + oldCap] = hiHead;
65. }
66. }
67. }
68. }
69. }
70. return newTab;
71. }
关于HashMap的初始容量：
HashMap的几个构造方法最后都调用了这个构造方法:
1. public HashMap(int initialCapacity, float loadFactor) {
2. if (initialCapacity < 0) //给定初始长度<0则抛异常
3. throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity);
4. if (initialCapacity > MAXIMUM_CAPACITY) //给定初始长度太大，则设为默认最大容量
5. initialCapacity = MAXIMUM_CAPACITY;
6. if (loadFactor <= 0 || Float.isNaN(loadFactor)) //给定负载因子<0或者不是数字，抛异常
7. throw new IllegalArgumentException("Illegal load factor: " +
8. loadFactor);
9. this.loadFactor = loadFactor; //负载因子采用给定值
10. this.threshold = tableSizeFor(initialCapacity); //阈值利用初始容量，通过一个方法进行计算
11. }
计算方法：
1. static final int tableSizeFor(int cap) {
2. int n = cap - 1;
3. n |= n >>> 1; // n = n | n >>> 1
4. n |= n >>> 2;
5. n |= n >>> 4;
6. n |= n >>> 8;
7. n |= n >>> 16;
8. return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
9. }
这个方法的作用就是无论初始容量是多少，最终的容量都将计算为不小于初始容量的2的最小次幂；比如初始容量为4，则经变化后初始容量仍为4，若初始容量为5，则变化后容量应该为8而不是5；之所以这么变化，是因为resize的机制中计算方式，table的长度必须为2的幂，否则计算方式会出错，而且计算起来会比现在复杂。
HashMap的遍历：
我们最常用的遍历方式为：
Iterator<Map.Entry<String, String>> iterator;
iterator = hashMap.entrySet().iterator();
while (iterator.hasNext()) {
Map.Entry<String, String> next = iterator.next();
String key = next.getKey();
String value = next.getValue();
}
我们通过map得到了一个entrySet对象，然后又获取了一个Iterator对象，最终就是通过这个Iterator来遍历的，那么这个Iterator是怎么个结构，如何实现遍历的呢？
final class EntrySet extends AbstractSet<Map.Entry<K,V>> {
public final int size() { return size; }
public final void clear() { HashMap.this.clear(); }
public final Iterator<Map.Entry<K,V>> iterator() {
return new EntryIterator();
}
//......
}
这个EntryIterator的代码：
final class EntryIterator extends HashIterator
implements Iterator<Map.Entry<K,V>> {
public final Map.Entry<K,V> next() { return nextNode(); }
}
HashIterator的代码：
abstract class HashIterator {
Node<K,V> next; // next entry to return
Node<K,V> current; // current entry
int expectedModCount; // for fast-fail
int index; // current slot
HashIterator() { //构造方法
expectedModCount = modCount;
Node<K,V>[] t = table; //map中哈希表的数组
current = next = null;
index = 0;
if (t != null && size > 0) { // advance to first entry
do {} while (index < t.length && (next = t[index++]) == null);//找到数组中第一个非空元素，赋值给next
}
}
public final boolean hasNext() {
return next != null;
}
final Node<K,V> nextNode() {
Node<K,V>[] t;
Node<K,V> e = next;
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
if (e == null)
throw new NoSuchElementException();
if ((next = (current = e).next) == null && (t = table) != null) {//本链表找完了，顺着数组找下一个链表，然后遍历
do {} while (index < t.length && (next = t[index++]) == null);
}
return e;
}
}
总结，遍历的过程就是找到数组中第一链表开始的位置，顺着遍历完本链表，然后顺着数组找第二个链表的位置，然后遍历第二个链表，这样一条链表一条链表的顺着来的。
---------------------------------------------------------------------------------------------------------------------------------------
ps：LinkedHashMap的结构跟HashMap相同，只是由单向链表改为了双向链表。
本来准备再看一下HashSet的，结果，，，，这就是个限制了功能的HashMap，，，，https://blog.csdn.net/sugar_rainbow/article/details/68257208