概要
JDK1.7中的HashMap底层实现为数组+链表,JDK1.7中的HashMap存在问题:多线程状态下内部数组扩容时有可能会导致死循环。所以,JDK1.8中对HashMap进行了重新实现,其底层实现为数组+链表+红黑树。提高了HashMap的性能。
HashMap源码解读
内部属性
static final int DEFAULT_INITIAL_CAPACITY默认初始化容量,默认值16,要求改值必须为2的幂次方数。至于为何必须是2的幂次方数,简单来说就是为了提高map的key在放入数组时候的散列性,将在下文分析。
static final int MAXIMUM_CAPACITY
默认值为1<<30,数组最大容量。
static final float DEFAULT_LOAD_FACTOR
默认负载因子,默认值为0.75,数组会根据负载因子*当前容量决定是否需要扩容。
static final int TREEIFY_THRESHOLD
树形化阈值,默认值为8,当数组内链表长度超过当前值后,会考虑将其转换为红黑树结构以提升效率。当前阈值是决定是否转换为红黑树的条件之一。
static final int UNTREEIFY_THRESHOLD
反树形化阈值,默认为6,当红黑树节点少于当前值时候,会从红黑树转换为链表结构。
static final int MIN_TREEIFY_CAPACITY
最小树形化容量阈值,默认值64,当数组容量超过当前值,会考虑将数组中链表转换为红黑树结构,和TREEIFY_THRESHOLD共同判断是否需要转换为红黑树。
transient Node<K,V>[] table
HashMap中用于存储数据的数组
存储数据的执行流程
存储数据源码分析
map存储数据需要调用put方法,下面将从put方法切入
public V put(K key, V value) {
//调用putVal向数组中添加数据
return putVal(hash(key), key, value, false, true);
}
put方法内部会调用putVal方法,以下是putVal执行流程
/**
* hash: 待存入数据的key值的hash值
* key: 待存入数据的key值
* value: 待存入数据的value值
* onlyIfAbsent: 如果key值相等,是否覆盖原有值
* evict: 数组处于创建状态标识
* V:返回值为当前key值的旧值,如果不存在就返回null
**/
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
//因为table属性为懒加载,所以首次调用put方法时将会调用resize方法创建table属性
if ((tab = table) == null || (n = tab.length) == 0)
//初始化table并得到当前数组长度
n = (tab = resize()).length;
/**
* p=tab[i=(n-1)&hash]用于获取数组中key将要放置的节点位置
* 通过`(n-1)&hash`得到其下标,这也是为什么数组容量要求为2的幂次方的原因所在(当n为2的幂次方数时,n-1的二进制值得所有低位都为1,这样在和hash执行&运算时,使结果只根hash的值相关,提高了结果的分散性)。为了保证数组容量为2的幂次方数,内部也对用户传入的数组容量做了处理,见tableSizeFor方法。
*
* 如果当前位置的节点为null,说明当前位置未曾放置对象,可直接创建节点对象,并放入数组
**/
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
else {
//当前位置已经存在节点:
Node<K,V> e; K k;
//根据当前key值计算出的位置存在节点且节点key和当前key相等,则把e变量指向已存在节点的引用,在最后修改并返回旧值
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
//当前位置已存的节点如果是树节点,执行向树中添加节点
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
//如果当前位置为链表,就遍历链表结构
for (int binCount = 0; ; ++binCount) {
//遍历链表,直到找到链表最后一个元素,将当前待存放的数据存入尾结点的next属性
//这里和JDK1.7中不同的是,JDK1.7中向链表中新增元素是头插法,而JDK1.8这里则是尾插法
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
//链表中新增数据后,判断链表长度是否超过`TREEIFY_THRESHOLD`,调用`treeifyBin`内部判断是否转换为红黑树
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;
}
}
//e不为空说明存在key值相同的元素,返回旧值
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
++modCount;
//根据整个map中键值对的个数,判断当前数组是否需要扩容
//size>threshold则需要扩容
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
以下是HashMap中数组扩容的流程:
//内部数组扩容方法
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
//获取扩容前数组长度
int oldCap = (oldTab == null) ? 0 : oldTab.length;
//扩容前的扩容阈值
int oldThr = threshold;
int newCap, newThr = 0;
//如果旧数组容量大于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; // double threshold
}
//数组容量为0,但是阈值存在,则将阈值设置为扩容目标大小
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
//按照默认大小初始化数组
else { // zero initial threshold signifies using default
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"})
//按照新的数组容量大小,创建新的数组newTab
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
//如果扩容前数组为null,说明是第一次懒加载初始化数组,直接返回创建好的newTab即可。
//否则则为数组扩容
if (oldTab != null) {
//遍历旧表中每一个元素
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
//e指向扩容前table中各个元素的引用
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
//e.next==null说明当前位置链表只有一个元素,那么则根据e.hash&(newCap-1)重新计算在新表中的位置,并将e放到新表中
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;
//如果e是树节点,执行树节点拆分
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
//e节点是长度大于1的链表
else {
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
//使用do{}while循环遍历链表中的每一个元素,根据(e.hash&oldCap)是否为0将链表拆分为2个链表
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);
//将loHead为头结点的链表放在新表中和扩容前下标相同的位置
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
//将hiHead为头结点的链表放在[新表中和扩容前下标+扩容前数组长度]的位置
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
另外比较有意思的一个点是HashMap内部为了保证数组容量为2的幂次方数,会在tableSizeFor方法对外部传入的数组容量进行处理,使不论外部传的值是多少,总能得到一个2的幂次方数。
方法思路:主要利用的一个点就是任何一个2的幂次方数,其二进制的值只有一个二进制位为1,其余二进制位都为0。
static final int tableSizeFor(int cap) {
int n = cap - 1;
n |= n >>> 1;
n |= n >>> 2;
n |= n >>> 4;
n |= n >>> 8;
n |= n >>> 16;
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}
总结
通过对HashMap源码的学习可知:
HashMap在超过范围后会自动扩容,扩容会导致性能下降,所以在平时开发中尽可能的避免数组扩容,可以在创建HashMap中指定容量。
HashMap的添加数据中没有同步措施,所以在多线程环境下会有线程安全问题,多线程情况下可使用ConcurrentHashMap。
默认的负载因子值为0.75,是官方通过试验得出的经验值,最好不要动。
以jdk7为例说明:
HashMap map = new HashMap();
在实例化以后,底层创建了一个长度为16的一位数组Entry[] table。
···可能已经执行过多次put操作了···
map.put(key1,value1)
首先会调用key1所在类的hashCode()方法计算key1的哈希值,然后通过某种算法计算出key1在Entry数组中的存放位置。
如果此位置上没有存放数据,则(key1-value1)添加成功。
如果此位置上有数据,则比较key1和已经存放的数据(一个或多个数据,其中多个数据是以链表的形式存储)的哈希值
如果key1的哈希值和已经存放的数据的哈希值都不相同,则(key1-value1)添加成功。
如果key1的哈希值和已经存放的某一个数据(key2-value2)的哈希值相同,则调用key1所在类的equals(key2)方法
如果equals返回false,则(key1-value1)添加成功。
如果equals返回true,则使用value1替换value2。
在不断添加的过程中:会涉及到扩容问题,当超出临界值时且要存放的位置非空时,默认情况下,扩容为原来的2倍,并把原来的数据复制过来。
jdk8中:
new HashMap():底层没有创建一个长度为16的数组。
jdk8底层的数组是:Node[],而非Entry数组。
首次调用put()方法时,底层去创建长度为16的数组。
jdk7底层结构:数组+链表。
jdk8底层结构:数组+链表+红黑树。
当数组的某一个索引位置上的元素以链表形式存在的数据个数>8且当前数组的长度>64时,此时此索引位置上的所有数据由数组+链表改为使用数组+红黑树存储,
当数组的某一个索引位置上的元素以红黑树形式存在的数据个数<6时,此时此索引位置上的所有数据由数组+红黑树变为使用数组+链表存储。