HashMap底层实现原理
本文中描述的HashMap实现原理是基于JDK'1.8.x版本的。
一、存储方式
HashMap从命名上讲： 存在一个Hash，所以底层其实是用的是散列Hash的方式来存储内容的。而散列Hash具有一些弊端——当发生Hash碰撞后，不同的解决冲突的办法会造成不同的效率损失，所以效率不稳定。故，单纯的使用散列Hash存储数据，是有弊端的，所以java使用数组来实现散列Hash过程并将碰撞后的数据以链表的形式来保存。
于是我们得到了HashMap的底层数据存储方式：数组（实现散列Hash） + 链表的方式来保存数据。
注意：这里没有结束，因为在链表长度唱过一定值后，链表的定位效率会直线下降，所以需要将链表进化成一种树结构，叫做红黑树（AVL）， 是一种弱平衡的二叉查找树。看下文：
什么是Hash，什么是散列Hash
Hash是一个算法簇，是满足某种条件的算法，我们都叫Hash算法。
1.算法结果是固定的，即固定的输入得到固定的结果
2.算法过程是不可逆的： 可以从输入推导出来结果，但不能从结果推导出输入来。
满足以上两个条件的算法，我们都叫他们Hash算法。就比如：加法就是一个Hash算法
3+5=8，在任何情况下，3+5都等于8，但是其中3+5是输入，8是结果，我们可以从3+5推导算出结果是8来，但不能从结果8，推算出输入就一定是3+5，也可能是1+7.
什么是散列Hash呢？
散列Hash是一种存放数据的方式，他并不是简单的加法或者减法。我们现在给出一系列数据。我们呢，就用这一系列数据来举例。
7，3 , 8 , 32 , 91 , 24 , 53
现在需要将这7个数字，放在某个容器里面。首先，我们使用数组（或者顺序表）容器来存放这7个数字。
第一步：我们需要创建一个长度至少为7的数组。
然后依次，将这些数据放在数组中。
| 内容 | 角标 |
|---|---|
| 7 | 0 |
| 3 | 1 |
| 8 | 2 |
| 32 | 3 |
| 91 | 4 |
| 24 | 5 |
| 53 | 6 |
这个就是用顺序表来存放数据的方式，但是除了这种存储方式以外，我们还有其他的存放方式，比如：链表。还有其他的结构可以存放内容，就比如：树、图等，这其中我们用的最多的保存过程就是Hash散列。
Hash散列也是一种存放过程，和数组存放非常像，只不过内容并不是按照数组保存的顺序来保存。
首先，我们也要创建一个长度（至少）是7的数组。
散列过程和线性表过程的不同地方，在于输入的数据，是要根据某种算法来决定这个数据放置在哪个位置上的。而不是根据输入的先后顺序来决定数据应该放在数据的哪个位置上。
我们用最简单的算法来处理：求余数》
当前数组长度是7，那么我们就要放置的元素去针对7取余数，这个余数只能是0—6之间。
按照这个过程，我们重新放置7，3 , 8 , 32 , 91 , 24 , 53这些内容
| 内容 | 角标 | 最终位置 |
|---|---|---|
| 7 | 0 | 0 |
| 3 | 3 | 3 |
| 8 | 1 | 1 |
| 32 | 4 | 4 |
| 91 | 0 ? | 2 |
| 24 | 3 ? | 5 |
| 53 | 4 ? | 6 |
我们发现，有几个值的角标算完和之前放置进来的值的角标是一样的，但是数组中这个位置如果已经有数据保存在这里了，就不能将新的数据保存在同一个角标下。
这个就是发生了Hash碰撞（Hash冲突）：当我们想要放置某个值到某个位置的时候，发现那个位置上已经有值了。这个过程就是由于选择的Hash算法针对这两个输入得到的结果是一样的。
注意：发生Hash冲突之后，我们就要想办法解决这个Hash冲突，要不然这个数据就没有办法放置在容器里面了。
我们通过偏移当前要放置的值，来改变这个值可能的角标。
于是，我们最终得到的结果就如以上表格所示
上面说的解决Hash冲突的过程是一种解决方式，但是java并没有选择用这个方式来解决实际发生在HashMap中的Hash冲突。
首先，HashMap的底层，也是一个数组，一个叫做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(int hash, K key, V value, Node<K,V> next) {
this.hash = hash;
this.key = key;
this.value = value;
this.next = next;
}
}
Node的部分源码如上所示： HashMap创建的就是这个Node的数组。
通过上图，我们知道HashMap实际上使用了拉链法来解决Hash冲突问题。
常见的参数以及参数含义
我们通过几个问题来引出参数：
-
一、当我们知道HashMap底层使用的是数组加链表来保存数据的时候，那么数组是有一个特点的，特点是数组是有固定长度的，那这个数组长度是多少？
-
二、如果我们放置的内容过多的时候，这个数组是不是要扩容呢？如果是，有要怎样扩容？
我们知道ArrayList是会扩容的，但是HashMap因为已经通过链表保证每一个元素都可以放在数组的某一个位置上，放不下就形成链表，那么他还需要扩容吗？
-
三、他一定是使用链表来保存数据么？用链表保存数据会不会出现什么问题呢？遇到这个问题的时候，要怎么解决呢？
问题解决（源码部分）：
//HashMap源代码中常见的参数：
//组成HashMap底层的数组：“table”--存放数据的地方。
transient Node<K,V>[] table;
//默认初始化容量 (Default_Initial_Capacity)：
//数组的初始化长度必须是2的幂次方。
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
//数组最大容量：(不是只能放这些值)
static final int MAXIMUM_CAPACITY = 1 << 30;
//默认装载因子：(装载因子用来衡量HashMap满的程度,从而扩容)
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//树化阈值：即 链表转成红黑树的阈值，在存储数据时，当链表长度 > 该值时，
//则将链表转换成红黑树
static final int TREEIFY_THRESHOLD = 8;
//链表还原阈值：即 红黑树转为链表的阈值
static final int UNTREEIFY_THRESHOLD = 6;
//转换成红黑树的前提：最小的数组容量为64，如果<64,则需要将数组扩容
static final int MIN_TREEIFY_CAPACITY = 64;
map.put();方法流程（底层源代码）
//put的源码，可知它所调用的是putVal()方法
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
putVal（）；方法详细：
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
//其中的参数如上：hash——> hash(key) , onlyonlyIfAbsent ——> false
// evict ——> true
//其中的代码块省略
}
1.方法的运行首先来运行hash(key)方法，得到hash
static final int hash(Object key) {
int h;
//r如果key不是null，则先将key的字符转换成hashCode值，把他转换成二进制
//在做h >>> 16，此时两者都是二进制，最后在计算 “ ^ ” 部分
//^（异或）：上下相同是0，上下不同是1.
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
2、正式运行方法putVal() ;
//Node<K,V>[] tab是存放数据的底层数组
//Node<K,V> p 是单一的一个节点—— p(present 当前的).
//int n ——> number当前数组的长度； i ——> index 是索引(角标)，即当前元素放置的位置
Node<K,V>[] tab; Node<K,V> p; int n, i;
// "||":只要两边一个为真，则整体为真
//table没有进行初始化，所以table == null.
if ((tab = table) == null || (n = tab.length) == 0)
//resize();改变大小——扩容，方法见3.
//第一次，返回的newTab长度
n = (tab = resize()).length;
//&: 上下都是1，得1，其余情况得0
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
//因为放入第一个值的时候，上面的运行，所以else先省略，看4
}
++modCount;
//++size 先加在用
if (++size > threshold)
resize();
//这个是给HashMap的子类———— LinkedHashMap使用的
afterNodeInsertion(evict);
return null;
}
3.resize();扩容方法见下：
final Node<K,V>[] resize() {
//先创建oldTab数组，使table赋值给他
Node<K,V>[] oldTab = table;
//oldCap 为旧的容量：如果oldTab为null，则oldCap为0.
int oldCap = (oldTab == null) ? 0 : oldTab.length;
//因为threshold没有赋值，所以默认为0.
int oldThr = threshold;//阈(yu 四声)值
int newCap, newThr = 0;
//因为第一次运行时oldCap = 0；oldThr = 0
//省略(1),两个if—— if (oldCap > 0)， else if (oldThr > 0)，看5
if (oldCap > 0){}
else if (oldThr > 0){}
else {
//DEFAULT_INITIAL_CAPACITY = 16
//DEFAULT_LOAD_FACTOR = 0.75; 0.75*16 = 12.0 ——>(int)——>12
//newCap = 16; newThr = 12.
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
if (newThr == 0) {
//因为newThr == 12所以先省略不看
}
threshold = newThr;//12
//又创建了一个长度为16的数组newTab
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
//因为第一次运行时，oldTab == null，
//所以省略(2)—— if (oldTab != null)
if (oldTab != null){}
return newTab;
}
4.开始放第二个值：
在放入第一个值的时候，因为数组（长度为16）为空，所以可以在任意位置填入。
而在放入第二个值的时候，则会出现以下几种情况：
1.放在数组中空的位置
2.要放在第一个数所在的位置，因为在这个位置上有值，所以：1.通过拉链法与第一个值相连； 2.放在其他空的数组位置。
//putVal()方法中省略（1） if ((p = tab[i = (n - 1) & hash]) == null) tab[i] = newNode(hash, key, value, null); else { //因为放入第一个值得时候，以上的if成立，但在放入第二个是的时候p!= null Node<K,V> e; K k; //p.hash是第一个值的hash， hash是本次输入的第二个值的hash，进行判断 //但由于只凭借hash不能确定，所以要比较key值，如果一样就会进行覆盖 //&&:两边都是真，才得真； ||：两边任何一个为真，便是真 if (p.hash == hash && ((k = p.key) == key || (key != null && key.equals(k)))) e = p; //p instanceof TreeNode表示只有p是树的情况 else if (p instanceof TreeNode) e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value); else { //此时第二个值的key或者hash不相同 for (int binCount = 0; ; ++binCount) { //e = p.next是看此结点上的链表的下一个位置，如果是null，那么p就是链表的尾巴 if ((e = p.next) == null) { //已知p.next为空，就将第二个值放在此处 p.next = newNode(hash, key, value, null); //如果链表长度为8的时候，则将该位置的链表转化成树 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正指向链表的第二个值，所以此步骤 //便是将p和e都指向链表的第二个值，并开始“放入第二个值”的操作 p = e; } } //由上可知，如果hash值相同，且key值相同，e = p； if (e != null) { // existing mapping for key V oldValue = e.value; //onlyIfAbsent在一开始便被定义为false，所以 !onlyIfAbsent为true if (!onlyIfAbsent || oldValue == null) //进行覆盖，使第一个值的位置被第二个值所取代 //我们可以看出被覆盖的条件：hash值相同，key值相同 e.value = value; afterNodeAccess(e); return oldValue; } }
此过程简化为：
从根结点向后查找，对比key值是否一致，或通过equals()判断是否为同一个对象，如果他们是同一个对象，那么就将value值替换掉。如果不是同一个对象，那么就找下一个结点，如果该结点为null，那么便将新的对象放在此结点上；如果下个结点不是null，那么继续对比key值，若key值相同，那么就将此结点的value值替换，否则继续寻找下一个结点，直到我们找到的下个结点为null，然后把这个结果放进去。
5.当达到阈值是的rehash()过程
//正式启用：来改变数组容量
if (++size > threshold)
resize();
//因为需要扩容，所以oldCap = 16，oldThr = 12都开始>0
if (oldCap > 0) {
//MAXIMUM_CAPACITY = 2^30
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
//oldCap << 1 = 32
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
//oldThr << 1 = 24
newThr = oldThr << 1;
}
else if (oldThr > 0)
newCap = oldThr;
else {
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);
}
//由上部分可知：newThr = 24； newCap = 32.
threshold = newThr;
@SuppressWarnings({"rawtypes","unchecked"})
//又创建了一个新的表 ，容量为32
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
//oldTab是旧的数组——容量为16的表，因为有了值，所以oldTab != null
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {
//将表上有值（或者链表）清楚，但是此时的e还是在链表上指向链表头部
oldTab[j] = null;
if (e.next == null)
//将旧表中的数据转入到新表的newTab[e.hash & (newCap - 1)]位置中
//特点，在旧表的角标数+旧表容量——>（rehash();）
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // preserve order
//loHead低位的头结点；loTail低位的尾结点……next下一个结点
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
next = e.next;
if ((e.hash & oldCap) == 0) {
//将loHead和loTail结点放在e上，而后loTail随着e开始变化
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
//如果next != null 以上继续循环
} while ((e = next) != null);
//通过以上的步骤，可能将一个链表拆开，但他们还是存在联系，通过这部分，将联系切断
if (loTail != null) {
loTail.next = null;
//将低位的头部放入newTab[j]上，即为原来表一样角标的位置
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
//高位的头部则放在 newTab[j + oldCap]上面
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
6.链表转化成树（二叉树）
为什么要将链表变成树？
因为链表的查找速度慢，所以为了提高查找速度，换成了平衡二叉树来保存链表数据。
二叉树：一个节点，最多引出两个子树
平衡树：最深的叶子节点的深度减去最浅的叶子节点的深度得到的差值不大于1.
查找树：定义好一个根节点后，其规则是这样的——所有大于根节点值的子节点，放在该节点的右边，所有小于该节点值的节点放在该节点的左边
红黑树——>平衡二叉查找树
final void treeifyBin(Node<K,V>[] tab, int hash) {
int n, index; Node<K,V> e;
//n先看做16，MIN_TREEIFY_CAPACITY(最小树化容量) = 64，所以扩容
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
resize();//将tab的容量扩容到64
//找到那一条链来进行树化，和它的根节点
else if ((e = tab[index = (n - 1) & hash]) != null) {
TreeNode<K,V> hd = null, tl = null;
do {
//把原来的节点变成了新的节点——树节点（看下一个代码部分）
TreeNode<K,V> p = replacementTreeNode(e, null);
//先把原来的单向链表，变为双向的链表
if (tl == null)
hd = p;
else {
p.prev = tl;
tl.next = p;
}
tl = p;
} while ((e = e.next) != null);
//从这个节点开始，把他变成树节点treeify();
if ((tab[index] = hd) != null)
hd.treeify(tab);
}
}
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
TreeNode<K,V> parent; // 父节点
TreeNode<K,V> left; //左节点
TreeNode<K,V> right; //右节点
TreeNode<K,V> prev; // 前节点
boolean red;//是否为红节点
TreeNode(int hash, K key, V val, Node<K,V> next) {
super(hash, key, val, next);
}
变成树节点:
final void treeify(Node<K,V>[] tab) {
TreeNode<K,V> root = null;
//x = this表示谁调用，谁就是x
for (TreeNode<K,V> x = this, next; x != null; x = next) {
next = (TreeNode<K,V>)x.next;
//将x的左右节点设置成null
x.left = x.right = null;
if (root == null) {
//设置根节点，然后再进入循环
x.parent = null;
x.red = false;
root = x;
}
else {
//此时x随着链表的顺序，for循环变换
K k = x.key;
int h = x.hash;
Class<?> kc = null;
for (TreeNode<K,V> p = root;;) {
//dir方向 ，ph是p.hash
int dir, ph;
//根节点的key值
K pk = p.key;
if ((ph = p.hash) > h)
dir = -1;
else if (ph < h)
dir = 1;
//如果两者hash是一样的，那么就用tieBreakOrder()方法
else if ((kc == null &&
(kc = comparableClassFor(k)) == null) ||
(dir = compareComparables(kc, k, pk)) == 0)
dir = tieBreakOrder(k, pk);
//正式放入左右节点
TreeNode<K,V> xp = p;
//将P变为它的左子树或者柚子树
if ((p = (dir <= 0) ? p.left : p.right) == null) {
x.parent = xp;
if (dir <= 0)
xp.left = x;
else
xp.right = x;
//将二叉树进行旋转平衡
root = balanceInsertion(root, x);
break;
}
}
}
}
moveRootToFront(tab, root);
}
浙公网安备 33010602011771号