Java教程
JDK1.8的HashMap最全源码跟踪分析
本文主要是介绍JDK1.8的HashMap最全源码跟踪分析，对大家解决编程问题具有一定的参考价值，需要的程序猿们随着小编来一起学习吧！
目录
- 说明
- Put()流程
- Put() 详细源码跟踪
- 1. new HashMap();
- 2.put(key,value);
- hash(key)
- V putVal(hash(key), key, value, false, true);
- Node
JDK1.8的HashMap的底层实现：数组+链表/红黑树。
说明
Map是一种键值对的结构，就是常说的Key-Value结构，一个Map就是很多这样K-V键值对组成的，一个K-V结构我们将其称作Entry。
几个常量和变量：
（1）DEFAULT_INITIAL_CAPACITY：默认的初始容量 16
-
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // 1左移四位 10000
（2）MAXIMUM_CAPACITY：table数组的最大长度 2^ 30
-
static final int MAXIMUM_CAPACITY = 1 << 30;
（3）DEFAULT_LOAD_FACTOR：默认加载因子 0.75
-
static final float DEFAULT_LOAD_FACTOR = 0.75f;
（4）TREEIFY_THRESHOLD：默认树化阈值8，当链表的长度达到这个值后，要考虑树化
-
static final int TREEIFY_THRESHOLD = 8;
（5）UNTREEIFY_THRESHOLD：默认反树化阈值6，当树中的结点的个数达到这个阈值后，要考虑变为链表 (树的节点个数减少到6，变为链表，因为链表比树结构更简单)
-
static final int UNTREEIFY_THRESHOLD = 6;
（6）MIN_TREEIFY_CAPACITY：最小树化容量64
当单个的链表的结点个数达到8，并且table的长度达到64，才会树化。
当单个的链表的结点个数达到8，但是table的长度未达到64，会先扩容
-
static final int MIN_TREEIFY_CAPACITY = 64;
（7）Node<K,V>[] table：节点数组，长度为length
HashMap是Map接口的实现类，Node是HashMap的一个内部类，实现了Map.Entry接口
（8）size：记录有效映射关系的对数，也是Entry对象的个数
（9）int threshold：阈值，当size达到阈值时，考虑扩容
threshold = length * Load factor
threshold就是在此Load factor和length(数组长度)对应下，HashMap所能容纳的最大数据量的(Entry键值对)个数，超过这个数目就重新resize(扩容)。
（10）double loadFactor：加载因子，影响扩容的频率
Put()流程
case1：第一次添加数据(键值对)，首先调用resize()方法创建一个table[]数组，默认长度为16、加载因子为0.75，则threshold为12.
并且创建一个Node用于保存键值对，然后添加到table[i]中，i= (table.length - 1) & hash。（i的值一定不会超过table.length-1）
case2：不是第一次添加数据(键值对)，此新键值对为N，首先根据key计算table[i]的位置，然后分以下几种情况
①如果当前table[i]的当前位置已经有键值对P,并且N和P的映射关系相同，则用N的value替换P的value。
②如果当前table[i]的当前位置已经有键值对P,并且N和P的映射关系不相同
{
如果table[i]是以P为首节点的链表，采用for循环遍历此链表
{
如果有相同映射关系，则用N的value替换并退出循环（这一步并没有使链表变长，所以不用考虑树化）
如果没有相同映射关系，则需要将N添加到链尾，并且判断是否已满足树化阈值8。
{
如果满足，调用treeifyBin(tab, hash)
{table的长度达到64，树化链表;
table的长度未达到64，调用resize()将table扩容1倍}，然后退出循环。
如果不满足，直接退出for循环。
}
}
如果table[i]是以P为根节点的树，p调用putTreeVal方法单独处理（同样会替换之前存在的旧的相同映射）。
}
Put() 详细源码跟踪
1. new HashMap();
public HashMap() {
//加载因子赋值为0.75
this.loadFactor = DEFAULT_LOAD_FACTOR;
// all other fields defaulted 其他字段为默认值
//threshold是0
//table=null
//size = 0
}
2.put(key,value);
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
hash(key)
//目的：干扰hashcode值
static final int hash(Object key) {
int h;
//如果key是null，hash是零
//如果key非null，用key的hashcode值与与本身最高16位进行异或
//即用key的hashcode值高16位与低16位进行了异或干扰运算。
/*
index = hash & table.length-1
如果用key的原始的hashCode值 与 table.length-1 进行按位与，那么基本上高16没机会用上。
这样就会增加冲突的概率，为了降低冲突的概率，把高16位加入到hash信息中。
*/
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
V putVal(hash(key), key, value, false, true);
hash – hash for key
key – the key
value – the value to put
onlyIfAbsent – if true, don’t change existing value
evict – if false, the table is in creation mode.
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; //数组
Node<K,V> p; //一个结点
int n, i;//n是数组的长度 i是下标
//tab和table等价
//如果table是空的
if ((tab = table) == null || (n = tab.length) == 0){
n = (tab = resize()).length;//tab = resize();n = tab.length;
/*
resize()源码见后文
如果table是空的，resize()完成了:
①创建了一个长度为16的数组
②threshold = 12
n= 16
*/
}
//i = (n - 1) & hash ，下标 = 数组长度-1 & hash
//p = tab[i]
//if(p==null) 条件满足的话说明 table[i]还没有元素
if ((p = tab[i = (n - 1) & hash]) == null){
//把新的映射关系直接放入table[i]
tab[i] = newNode(hash, key, value, null);
//newNode（）方法就创建了一个Node类型的新结点，新结点的next是null
}else {
Node<K,V> e;
K k;
//p是table[i]中第一个结点
//if(table[i]的第一个结点与新的映射关系的key重复)
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k)))){
e = p;//用e记录这个table[i]的第一个结点
}else if (p instanceof TreeNode){//如果table[i]第一个结点是一个树结点
//单独处理树结点
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
}else {
//table[i]的第一个结点不是树结点，也与新的映射关系的key不重复
//binCount记录了table[i]下面的结点的个数
for (int binCount = 0; ; ++binCount) {
//如果p的下一个结点是空的，说明当前的p是最后一个结点
if ((e = p.next) == null) {
//把新的结点连接到table[i]的最后
p.next = newNode(hash, key, value, null);
//如果binCount>=8-1，达到7个时
if (binCount >= TREEIFY_THRESHOLD - 1){ // -1 for 1st
//要么扩容，要么树化
treeifyBin(tab, hash);
}
break;
}
//如果key重复了，就跳出for循环
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k)))){
break;
}
p = e;
}
}
//如果这个e不是null，说明有key重复，就考虑替换原来的value
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null){
e.value = value;
}
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
//元素个数增加
//size达到阈值
if (++size > threshold){
resize();//一旦扩容，重新调整所有映射关系的位置
}
afterNodeInsertion(evict);//什么也没干
return null;
}
Node<K,V>[] resize()
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;//oldTab原来的table
//oldCap：原来数组的长度
int oldCap = (oldTab == null) ? 0 : oldTab.length;
//oldThr：原来的阈值
int oldThr = threshold;//最开始threshold是0
//newCap，新容量
//newThr：新阈值
int newCap, newThr = 0;
if (oldCap > 0) {//说明原来不是空数组
if (oldCap >= MAXIMUM_CAPACITY) {//是否达到数组最大限制
threshold = Integer.MAX_VALUE;
return oldTab;
}else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY){
//newCap = 旧的容量*2 ，新容量<最大数组容量限制
//新容量：32,64，...
//oldCap >= 初始容量16
//新阈值重新算 = 24，48 ....
newThr = oldThr << 1; // double threshold
}
}else if (oldThr > 0){ // initial capacity was placed in threshold
newCap = oldThr;
}else { // zero initial threshold signifies using defaults
newCap = DEFAULT_INITIAL_CAPACITY;//新容量是默认初始化容量16
//新阈值= 默认的加载因子 * 默认的初始化容量 = 0.75*16 = 12
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;//阈值赋值为新阈值12，24.。。。
//创建了一个新数组，长度为newCap，16，32,64.。。
@SuppressWarnings({"rawtypes","unchecked"})
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
if (oldTab != null) {//原来不是空数组
//把原来的table中映射关系，倒腾到新的table中
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {//e是table下面的结点
oldTab[j] = null;//把旧的table[j]位置清空
if (e.next == null)//如果是最后一个结点
newTab[e.hash & (newCap - 1)] = e;//重新计算e的在新table中的存储位置，然后放入
else if (e instanceof TreeNode)//如果e是树结点
//把原来的树拆解，放到新的table
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // preserve order
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
/*
把原来table[i]下面的整个链表，重新挪到了新的table中
*/
do {
next = e.next;
if ((e.hash & oldCap) == 0) {
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
Node< K,V > newNode (int hash, K key, V value, Node<K,V> next)
Node<K,V> newNode(int hash, K key, V value, Node<K,V> next) {
//创建一个新结点
return new Node<>(hash, key, value, next);
}
treeifyBin(Node<K,V>[] tab, int hash)
final void treeifyBin(Node<K,V>[] tab, int hash) {
int n, index;
Node<K,V> e;
//MIN_TREEIFY_CAPACITY：最小树化容量64
//如果table是空的，或者 table的长度没有达到64
if (tab == null || (n = tab.length) < MIN_TREEIFY_CAPACITY)
resize();//先扩容
else if ((e = tab[index = (n - 1) & hash]) != null) {
//用e记录table[index]的结点的地址
TreeNode<K,V> hd = null, tl = null;
/*
do...while，把table[index]链表变为红黑树
*/
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);
if ((tab[index] = hd) != null)
hd.treeify(tab);
}
}
get()流程
1.通过hash(key)找到table[i]位置，如果恰好为第一个节点，直接命中；
2.如果有冲突，则通过key.equals(k)去查找对应的entry
若为树，则在树中通过key.equals(k)查找，O(logn)；
若为链表，则在链表中通过key.equals(k)查找，O(n)。
源码跟踪
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 && // 每次都是校验第一个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;
}
这篇关于JDK1.8的HashMap最全源码跟踪分析的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！
您可能喜欢
-
Springboot应用的多环境打包入门11-23
-
Springboot应用的生产发布入门教程11-23
-
Python编程入门指南11-23
-
Java创业入门：从零开始的编程之旅11-23
-
Java创业入门：新手必读的Java编程与创业指南11-23
-
Java对接阿里云智能语音服务入门详解11-23
-
Java对接阿里云智能语音服务入门教程11-23
-
JAVA对接阿里云智能语音服务入门教程11-23
-
Java副业入门：初学者的简单教程11-23
-
JAVA副业入门：初学者的实战指南11-23
-
JAVA项目部署入门：新手必读指南11-23
-
Java项目部署入门：新手必看指南11-23
-
Java项目部署入门：新手必读指南11-23
-
Java项目开发入门：新手必读指南11-23
-
JAVA项目开发入门：从零开始的实用教程11-23
栏目导航
