HashMap底层实现 1.8版本
先立个flag，把HashMap底层原理梳理并写下来留个备忘，先分以下4点列个提纲，后续完善
概述
HashMap的底层结构为数组+链表，Why?
先了解下数组的特性：读的快，写的慢。因为数组中的元素在内存中是连续的，所以在读取的时候根据坐标能快速拿到元素，但写的时候，因为连续，所以内存中可能要进行碎片的整理，内存的重新划分，故写入较慢；
再看下链表的特性：读的慢，写的快。原因刚好和数组相反，特性也相反。
故而HashMap取其长、避其短，采取了数组+链表这样的结构，来存储各个元素。数组坐标相同的元素(即hash冲突的情况下)，就通过链表链接起来
Hash原理
现在已经知道了数组+链表的结构了，那如何确定元素在数组中的坐标呢。元素中有2个关键的属性，key和value，Hash值是根据key来获取到的，并且保证了Hash的离散性，具体实现如下：
方法一：获取hash值
static final int hash(Object key) { //jdk1.8 & jdk1.7
int h;
// h = key.hashCode() 为第一步 取hashCode值
// h ^ (h >>> 16) 为第二步 高位参与运算
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
方法二：获取数组下标
static int indexFor(int h, int length) { //jdk1.7的源码，jdk1.8没有这个方法，但是实现原理一样的
return h & (length-1); //第三步 取模运算，和h%(length-1)类似，但效率要高
}
以上逻辑的图例说明
Put原理
现在算出来了元素在数组的坐标，就可以往里面放元素啦，当然这个逻辑是有点复杂的。具体如下：
①.判断键值对数组table[i]是否为空或为null，为null则执行resize()进行扩容；
②.根据键值key计算hash值得到插入的数组索引i，如果table[i]==null，直接新建节点添加，转向⑥，如果table[i]不为空，转向③；
③.判断table[i]的首个元素是否和key一样，如果相同直接覆盖value，否则转向④，这里的相同指的是hashCode以及equals；
④.判断table[i] 是否为treeNode，即table[i] 是否是红黑树，如果是红黑树，则直接在树中插入键值对，否则转向⑤；
⑤.遍历table[i]，判断链表长度是否大于8，大于8的话把链表转换为红黑树，在红黑树中执行插入操作，否则进行链表的插入操作(此时插入的顺序为当前链表的末尾！！！只有在resize的时候，插入为链表的表头！！！)；遍历过程中若发现key已经存在直接覆盖value即可；
⑥.插入成功后，判断实际存在的键值对数量size是否超多了最大容量threshold，如果超过，进行扩容。
完美的图解如下：
Resize原理
HashMap中有几个重要属性，size:当前元素个数，threshold:加载因子，默认为0.75，length：数组长度，当满足size > length*threshold的时候，就要进行扩容了，即创建一个新的数组，长度为旧数组长度*2，然后所有元素开始往新数组中迁移，先看下JDK1.7是怎么实现的：
void resize(int newCapacity) { //传入新的容量
Entry[] oldTable = table; //引用扩容前的Entry数组
int oldCapacity = oldTable.length;
if (oldCapacity == MAXIMUM_CAPACITY) { //扩容前的数组大小如果已经达到最大(2^30)了
threshold = Integer.MAX_VALUE; //修改阈值为int的最大值(2^31-1)，这样以后就不会扩容了
return;
}
Entry[] newTable = new Entry[newCapacity]; //初始化一个新的Entry数组
transfer(newTable); //！！将数据转移到新的Entry数组里 ，重要的环节
table = newTable; //HashMap的table属性引用新的Entry数组
threshold = (int) (newCapacity * loadFactor);//修改阈值
}
transfer()方法将原有Entry数组的元素拷贝到新的Entry数组里。
void transfer(Entry[] newTable) {
Entry[] src = table; //src引用了旧的Entry数组
int newCapacity = newTable.length;
for (int j = 0; j < src.length; j++) { //遍历旧的Entry数组
Entry<K, V> e = src[j]; //取得旧Entry数组的每个元素
if (e != null) {
src[j] = null;//释放旧Entry数组的对象引用（for循环后，旧的Entry数组不再引用任何对象）
do {
Entry<K, V> next = e.next;
int i = indexFor(e.hash, newCapacity); //！！重新计算每个元素在数组中的位置
e.next = newTable[i]; //将当前元素的next属性，指向数组i下标的元素，比如此时e为B元素，newTable[i]元素为A，则B元素的下一个元素指向A
newTable[i] = e; //将元素B放在数组i下标上，即newTable[i]=B，且B.next==A，完美的把旧元素逆序放到了新链表中
e = next; //访问下一个Entry链上的元素
} while (e != null);
}
}
}
static int indexFor(int h, int length) {
return h & (length - 1);
}
参考图例：
看完了jdk1.7的resize实现，我们再看看1.8是如何做的，先说结论： 不像1.7那样每个元素重新计算数组中的位置，1.8在经过rehash之后，元素的位置要么是在原位置，要么是在原位置再移动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不会倒置。
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) {
// 超过最大值就不再扩充了，就只好随你碰撞去吧
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
//数组扩大为原来2倍
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; //值域扩大为原来2倍
}
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
else { // zero initial threshold signifies using defaults
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;
if (oldTab != null) {
//开始遍历旧数组中的每一个坐标下的元素
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {
//释放旧数组j位置的内存空间
oldTab[j] = null;
if (e.next == null)
//旧数据j位置只有1个元素，则直接计算该元素在新数组中的位置，并放进去
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;
//数组坐标需要移动为原位置+oldCap的元素
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
//当前元素的下一位，指向新添加的元素，比如e为旧数组中的B元素，loTail为新数组中的A元素，则A.next指向B元素
loTail.next = e;
//将loTail指向B元素，故新的数组中，链表上元素的顺序，与旧数组链表顺序一致
loTail = e;
}
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
if (loTail != null) {
loTail.next = null;
//将链表挂载到新数组的j位置
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
Get原理
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;
if ((tab = table) != null && (n = tab.length) > 0 && (first = tab[(n - 1) & hash]) != null) {
// 检查第一个元素，相等就直接返回
if (first.hash == hash && ((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;
}
并发问题
未完待续……
参考：https://blog.csdn.net/visant/article/details/80045154
http://www.importnew.com/20386.html
https://blog.csdn.net/aichuanwendang/article/details/53317351#commentsedit
2万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
