Java HashMap底层实现原理源码分析Jdk8
在JDK1.6，JDK1.7中，HashMap采用位桶+链表实现，即便用链表处理冲突，同一hash值的链表都存储在一个链表里。可是当位于一个桶中的元素较多，即hash值相等的元素较多时，经过key值依次查找的效率较低。而JDK1.8中，HashMap采用位桶+链表+红黑树实现，当链表长度超过阈值（8）时，可能会将链表转换为红黑树，这样大大减小了查找时间。html
简单说下HashMap的实现原理：
首先存在一个table数组，里面每一个元素都是一个node链表，当添加一个元素（key-value）时，就首先计算元素key的hash值，经过table的长度和key的hash值进行与运算获得一个index，以此肯定插入数组中的位置，可是可能存在同一hash值的元素已经被放在数组同一位置了，这时就把这个元素添加到同一hash值的node链表的链尾，他们在数组的同一位置，可是造成了链表，同一各链表上的Hash值是相同的，因此说数组存放的是链表。而当链表长度大于等于8时，链表就可能转换为红黑树，这样大大提升了查找的效率。java
存储结构
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;
}
*
*
*
}
transient Node<K,V>[] table;
- HashMap内部包含一个Node类型的数组table，Node由Map.Entry继承而来。
- Node存储着键值对。它包含四个字段，从next字段咱们能够看出node是一个链表。
- table数组中的每一个位置均可以当作一个桶，一个桶存放一个链表。
- HashMap使用拉链法来解决冲突，同一个存放散列值相同的Node。
数据域
// 序列化ID private static final long serialVersionUID = 362498820763181265L; // 初始化容量，初始化有16个桶 static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16 // 最大容量 1 073 741 824, 10亿多 static final int MAXIMUM_CAPACITY = 1 << 30; // 默认的负载因子。所以初始状况下，当键值对的数量大于 16 * 0.75 = 12 时，就会触发扩容。 static final float DEFAULT_LOAD_FACTOR = 0.75f; // 当put()一个元素到某个桶，其链表长度达到8时有可能将链表转换为红黑树 static final int TREEIFY_THRESHOLD = 8; // 在hashMap扩容时，若是发现链表长度小于等于6，则会由红黑树从新退化为链表。 static final int UNTREEIFY_THRESHOLD = 6; // 在转变成红黑树树以前，还会有一次判断，只有键值对数量大于 64 才会发生转换，否者直接扩容。这是为了不在HashMap创建初期，多个键值对刚好被放入了同一个链表中而致使没必要要的转化。 static final int MIN_TREEIFY_CAPACITY = 64; // 存储元素的数组 transient Node<k,v>[] table; // 存放元素的个数 transient int size; // 被修改的次数fast-fail机制 transient int modCount; // 临界值 当实际大小(容量*填充比)超过临界值时，会进行扩容 int threshold; // 填充比 final float loadFactor;
构造函数
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
public HashMap(int initialCapacity, float loadFactor) {
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
this.loadFactor = loadFactor;
// tableSizeFor(initialCapacity)方法计算出接近initialCapacity
// 参数的2^n来做为初始化容量。
this.threshold = tableSizeFor(initialCapacity);
}
public HashMap(Map<? extends K, ? extends V> m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m, false);
}
HashMap构造函数容许用户传入容量不是2的n次方，由于它能够自动地将传入的容量转换为2的n次方。node
put()操做源码解析
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
static final int hash(Object key) {
int h;
// “扰动函数”。参考 https://www.cnblogs.com/zhengwang/p/8136164.html
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
HashMap.Node<K,V>[] tab; HashMap.Node<K,V> p; int n, i;
// 未初始化则初始化table
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
// 经过table的长度和hash与运算获得一个index，
// 而后判断table数组下标为index处是否已经存在node。
if ((p = tab[i = (n - 1) & hash]) == null)
// 若是table数组下标为index处为空则新建立一个node放在该处
tab[i] = newNode(hash, key, value, null);
else {
// 运行到这表明table数组下标为index处已经存在node，即发生了碰撞
HashMap.Node<K,V> e; K k;
// 检查这个node的key是否跟插入的key是否相同。
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
// 检查这个node是否已是一个红黑树
else if (p instanceof TreeNode)
// 若是这个node已是一个红黑树则继续往树种添加节点
e = ((HashMap.TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
for (int binCount = 0; ; ++binCount) {
// 在这里循环遍历node链表
// 判断是否到达链表尾
if ((e = p.next) == null) {
// 到达链表尾，直接把新node插入链表，插入链表尾部，在jdk8以前是头插法
p.next = newNode(hash, key, value, null);
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
// 若是node链表的长度大于等于8则可能把这个node转换为红黑树
treeifyBin(tab, hash);
break;
}
// 检查这个node的key是否跟插入的key是否相同。
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
// 当插入key存在，则更新value值并返回旧value
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
// 修改次数++
++modCount;
// 若是当前大小大于门限，门限本来是初始容量*0.75
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
- 下面简单说下put()流程：
- 判断键值对数组table[]是否为空或为null，不然以默认大小resize()；
- 根据键key计算hash值与table的长度进行与运算获得插入的数组索引 index，若是tab[index] == null，直接根据key-value新建node添加，不然转入3
- 判断当前数组中处理hash冲突的方式为链表仍是红黑树(check第一个节点类型便可),分别处理
- 为啥头插法为何要换成尾插：jdk1.7时候用头插法多是考虑到了一个所谓的热点数据的点(新插入的数据可能会更早用到)；找到链表尾部的时间复杂度是 O(n)，或者须要使用额外的内存地址来保存链表尾部的位置，头插法能够节省插入耗时。可是在扩容时会改变链表中元素本来的顺序，以致于在并发场景下致使链表成环的问题。
- 从putVal()源码能够看出，HashMap并无对null的键值对作限制（hash值设为0），即HashMap容许插入键尾null的键值对。但在JDK1.8以前HashMap使用第0个node存放键为null的键值对。
- 肯定node下标：经过table的长度和key的hash进行与运算获得一个index。
- 在转变成红黑树树以前，还会有一次判断，只有键值对数量大于 64 才会发生转换，否者直接扩容。这是为了不在HashMap创建初期，多个键值对刚好被放入了同一个链表中而致使没必要要的转化。
get()操做源码解析
public V get(Object key) {
HashMap.Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
final HashMap.Node<K,V> getNode(int hash, Object key) {
HashMap.Node<K,V>[] tab; HashMap.Node<K,V> first, e; int n; K k;
// table不为空
if ((tab = table) != null && (n = tab.length) > 0 &&
// 经过table的长度和hash与运算获得一个index，table
// 下标位index处的元素不为空，即元素为node链表
(first = tab[(n - 1) & hash]) != null) {
// 首先判断node链表中中第一个节点
if (first.hash == hash && // always check first node
// 分别判断key为null和key不为null的状况
((k = first.key) == key || (key != null && key.equals(k))))
// key相等则返回第一个
return first;
// 第一个节点key不一样且node链表不止包含一个节点
if ((e = first.next) != null) {
// 判断node链表是否转为红黑树。
if (first instanceof HashMap.TreeNode)
// 则在红黑树中进行查找。
return ((HashMap.TreeNode<K,V>)first).getTreeNode(hash, key);
do {
// 循环遍历node链表中的节点，判断key是否相等
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
// key在table中不存在则返回null。
return null;
}
- get(key)方法首先获取key的hash值，
- 计算hash & (table.len - 1)获得在链表数组中的位置，
- 先判断node链表（桶）中的第一个节点的key是否与参数key相等，
- 不等则判断是否已经转为红黑树，若转为红黑树则在红黑树中查找，
- 如没有转为红黑树就遍历后面的链表找到相同的key值返回对应的Value值便可。
resize()操做源码解析
// 初始化或者扩容以后的元素调整
final HashMap.Node<K,V>[] resize() {
// 获取旧table
HashMap.Node<K,V>[] oldTab = table;
// 旧table容量
int oldCap = (oldTab == null) ? 0 : oldTab.length;
// 旧table扩容临界值
int oldThr = threshold;
// 定义新table容量和临界值
int newCap, newThr = 0;
// 若是原table不为空
if (oldCap > 0) {
// 若是table容量达到最大值，则修改临界值为Integer.MAX_VALUE
// MAXIMUM_CAPACITY = 1 << 30;
// Integer.MAX_VALUE = 1 << 31 - 1;
if (oldCap >= MAXIMUM_CAPACITY) {
// Map达到最大容量，这时还要向map中放数据，则直接设置临界值为整数的最大值
// 在容量没有达到最大值以前不会再resize。
threshold = Integer.MAX_VALUE;
// 结束操做
return oldTab;
}
// 下面就是扩容操做（2倍）
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
// 临界值也变为两倍
newThr = oldThr << 1; // double threshold
}
else if (oldThr > 0) // initial capacity was placed in threshold
/*
* 进入此if证实建立HashMap时用的带参构造：public HashMap(int initialCapacity)
* 或 public HashMap(int initialCapacity, float loadFactor)
* 注：带参的构造中initialCapacity（初始容量值）不论是输入几都会经过
* tableSizeFor(initialCapacity)方法计算出接近initialCapacity
* 参数的2^n来做为初始化容量。
* 因此实际建立的容量并不等于设置的初始容量。
*/
newCap = oldThr;
else { // zero initial threshold signifies using defaults
// 进入此if证实建立map时用的无参构造：
// 而后将参数newCap（新的容量）、newThr(新的扩容阀界值)进行初始化
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
if (newThr == 0) {
// 进入这表明有两种可能。
// 1. 说明old table容量大于0可是小于16.
// 2. 建立HashMap时用的带参构造，根据loadFactor计算临界值。
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
// 修改临界值
threshold = newThr;
@SuppressWarnings({"rawtypes","unchecked"})
// 根据新的容量生成新的 table
HashMap.Node<K,V>[] newTab = (HashMap.Node<K,V>[])new HashMap.Node[newCap];
// 替换成新的table
table = newTab;
// 若是oldTab不为null说明是扩容，不然直接返回newTab
if (oldTab != null) {
/* 遍历原来的table */
for (int j = 0; j < oldCap; ++j) {
HashMap.Node<K,V> e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
// 判断这个桶（链表）中就只有一个节点
if (e.next == null)
// 根据新的容量从新计算在table中的位置index，并把当前元素赋值给他。
newTab[e.hash & (newCap - 1)] = e;
// 判断这个链表是否已经转为红黑树
else if (e instanceof HashMap.TreeNode)
// 在split函数中可能因为红黑树的长度小于等于UNTREEIFY_THRESHOLD（6）
// 则把红黑树从新转为链表
((HashMap.TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // preserve order
// 运行到这里证实桶中有多个节点。
HashMap.Node<K,V> loHead = null, loTail = null;
HashMap.Node<K,V> hiHead = null, hiTail = null;
HashMap.Node<K,V> next;
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;
}
- 在达到最大值MAXIMUM_CAPACITY以后仍能够put数据。
- 带构造参数初始化过程当中，实际建立的容量并不等于设置的初始容量。tableSizeFor()方法能够自动的将传入的容量转换2的n次方。
- 红黑树能够退化成链表。
- 须要注意的是，扩容操做须要把oldTable的全部键值对从新插入newTable中，所以，这一步是很耗时的。
相关文章
- 1. Java ArrayList底层实现原理源码详细分析Jdk8
- 2. Java集合——HashMap底层实现与原理源码分析——JDK1.8
- 3. Java中HashMap底层实现原理(JDK1.8)源码分析
- 4. HashMap底层原理源码分析
- 5. HashMap底层实现(源码分析)
- 6. HashMap底层原理及源码分析
- 7. Java集合：HashMap底层实现和原理（源码解析）
- 8. HashMap底层实现原理(JDK1.8)源码分析
- 9. java HashMap源码分析(JDK8)
- 10. HashMap底层原理（源码剖析）
- 更多相关文章...
- • Git 分支管理 - Git 教程
- • Java操作Neo4j数据库（附带源码） - NoSQL教程
- • Java Agent入门实战（三）-JVM Attach原理与使用
- • Java Agent入门实战（二）-Instrumentation源码概述
相关标签/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
欢迎关注本站公众号,获取更多信息
