目录
HashMap
一、概况
HashMap继承AbstractMap,可允许一个键(key)为空,可允许多个值(value)为空。HashMap非线程安全,默认容量为16,默认负载因子为0.75,进行扩容之后容量为原来的2倍,HashMap容量只能为2的n次方幂。HashMap是数组+链表+红黑树实现,当链表长度大于等于8时,整个链表会转成红黑树。
二、HashMap结构
从结构实现来讲,HashMap是数组+链表+红黑树(JDK1.8增加了红黑树部分)实现的,如下如所示。
三、JDK1.8中源码分析
(一)创建HashMap
1、创建HashMap流程图
1、创建HashMap对象
/**
* 构造一个空的HashMap,指定初始容量和默认的负载系数(0.75)。
* @param 传入的初始容量.
*/
//默认负载因子0.75
static final float DEFAULT_LOAD_FACTOR = 0.75f;
public HashMap(int initialCapacity) {
//调用有参构造方法,实例化hashMap对象
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
2、调用有参构造方法创建对象
/**
* 构造一个空的HashMap,指定初始容量和默认的负载系数(0.75)。
* @param 传入的初始容量.
* @param 默认负载因子0.75
*/
int threshold;
final float loadFactor;
//最大容量
static final int MAXIMUM_CAPACITY = 1 << 30;
public HashMap(int initialCapacity, float loadFactor) {
//判断传入的初始容量是否小于0,如果小于0啧抛出异常,
//也可调用无参构造方法,则默认长度为16。
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
//判断传入的初始容量是否大于最大容量,如果大于则取最大容量的值
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
//判断负载因子是否小于0或者是否非法
//如果负载因子小于0或非法,则抛出异常
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
//给变量负载因子赋值
this.loadFactor = loadFactor;
//计算实际map容量,因为map容量只能为2的幂次方倍,
//所以随意传的一个容量也会被改变为大于initialCapacity的最小2的幂次方倍数
this.threshold = tableSizeFor(initialCapacity);
}
3、改变容量
/**
* 改变为大于initialCapacity的最小2的幂次方倍数
*/
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;
}
(二)put方法
1、调用putVal()方法
/**
* 如果存在key冲突那么会将旧值替换为新值,并返回旧值。
* @param key 传入的key值
* @param value 传入的value值
*/
public V put(K key, V value) {
//调用putValue方法。
return putVal(hash(key), key, value, false, true);
}
2、通过key获取key对应的hashCode
/**
* 通过key计算出hashCode
*/
static final int hash(Object key) {
int h;
//如果key为空,则hashcode为0,否则则计算出对应的值
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
问题:为什么要用 h = key.hashCode()) 与 (h >>> 16) 异或?
原因:在jdk1.7中有indexFor(int h, int length)方法。jdk1.8里没有,但原理没变。下面看下1.7源码1.8中用tab[(n - 1) & hash]代替但原理一样。
1. static int indexFor(int h, int length) {
2. return h & (length-1);
3. }
这个方法返回值就是数组下标。我们平时用map大多数情况下map里面的数据不是很多。这里与(length-1)相&,但由于绝大多数情况下length一般都小于2^16即小于65536。
所以return h & (length-1),结果始终是h的低16位与(length-1)进行&运算。要是高16位也参与运算,会让得到的下标更加散列。
所以这样高16位是用不到的,如何让高16也参与运算呢。所以才有hash(Object key)方法。让他的hashCode()和自己的高16位^运算。所以(h >>> 16)得到他的高16位与hashCode()进行^运算。
不用&和|的原因是:&和|都会使得结果偏向0或者1 ,并不是均匀的概念,所以用^。
3、putVal方法具体实现
(1)源码实现
/**
* 实现map中的put方法
*
* @param hash 通过key获取到的hashcode值
* @param key 传入的key值
* @param value 传入的value值
* @param onlyIfAbsent 如果这个参数为true,则不会将新值替换掉旧值
* @param evict 如果这个参数为false,则表明这个hash表正在被创建
* @return 旧值,如果没有则为空
*/
static final int TREEIFY_THRESHOLD = 8;
transient Node<K,V>[] table;
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,boolean evict) {
Node<K,V>[] tab;
Node<K,V> p;
int n, i;
//判断数组是否为空
if ((tab = table) == null || (n = tab.length) == 0)
//resize()方法对数组进行初始化或扩容操作
//n记录数组长度(map是数组+链表+红黑树)
n = (tab = resize()).length;
//获取存放数组位置,如果原来数组位置为空则直接存
//hashmap精妙之处:tab[i = (n - 1) & hash]
//将数组的长度-1与hash值进行一个与运算,保证数组不会越界
//从而保证数组下标最大值为数组长度-1
//与运算与取模运算有异曲同工之妙,但是与运算效率更高
if ((p = tab[i = (n - 1) & hash]) == null)
//创建node对象,并存放到计算出的数组位置中
tab[i] = newNode(hash, key, value, null);
else {
//空节点对象e
Node<K,V> e;
K k;
//当前数组中对象
//判断如果传入的key及计算出的hash和当前位置对象一样,
//或者key不为空且key和当前位置对象key相同,
//则将当前对象赋值给e
//总结:判断头结点是否存在key冲突
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
//如果当前对象是树形节点
else if (p instanceof TreeNode)
//已经转为红黑树,则将对象放入树形节点中,并赋值给e
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
//如果当前为链表
else {
//循环
for (int binCount = 0; ; ++binCount) {
//如果链表指向的下一个节点为空
//将下个节点对象赋值给e
if ((e = p.next) == null) {
//创建一个新的节点对象并放入下个节点中
//也就是直接存在在下个位置(next位置)
p.next = newNode(hash, key, value, null);
//如果循环次数大于等于8
if (binCount >= TREEIFY_THRESHOLD - 1)
//转换为红黑树结构,并存值
treeifyBin(tab, hash);
//跳出循环
break;
}
//如果链表指向的下一个节点不为空
//如果key和hash相同,则保持不动并跳出循环
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
//如果key没有冲突,则应该继续循环
//因为要取下一个节点继续循环
p = e;
}
}
//如果e不为空,也就是存在key冲突时
if (e != null) { // existing mapping for key
//获取e的值oldValue
V oldValue = e.value;
//onlyIfAbsent 如果这个参数为true,则不会将新值替换掉旧值
//将新值放入,替换掉老值
if (!onlyIfAbsent || oldValue == null)
e.value = value;
//调用afterNodeAccess方法把元素添加至链表的尾部
afterNodeAccess(e);
//返回旧值
return oldValue;
}
}
//修改次数加1,
//modCount作用于迭代器快速失败
++modCount;
//size是当前已存入的对象(键值对)数
//size加1
//判断已存在对象数量是否大于阈值
//如果大于阈值则进行扩容操作
if (++size > threshold)
//扩容操作
resize();
//无作用,为子类LinkedHashMap服务
afterNodeInsertion(evict);
return null;
}
亮点:tab[i = (n - 1) & hash]方法将数组的长度-1与hash值进行一个与运算,保证数组不会越界,从而保证数组下标最大值为数组长度-1,与运算与取模运算有异曲同工之妙,但是与运算效率更高。
(2)流程图
(三)扩容
分为扩容操作、数据移动和流程图三部分。
1、扩容操作源码
/**
* 初始化或增加表大小。如果为null,则使用默认初始容量。
* 容量为2的n次方幂
*/
@Native public static final int MAX_VALUE = 0x7fffffff;
//默认初始容量16
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4;
//阈值
int threshold;
transient Node<K,V>[] table;
final HashMap.Node<K,V>[] resize() {
HashMap.Node<K,V>[] oldTab = table;
// 记录Map当前的容量
int oldCap = (oldTab == null) ? 0 : oldTab.length;
// 记录Map允许存储的元素数量,即阈值(容量*负载因子)
int oldThr = threshold;
// 声明两个变量,用来记录新的容量和阈值
int newCap, newThr = 0;
// 若当前容量不为0,表示存储数据的数组已经被初始化过
if (oldCap > 0) {
// 判断当前容量是否超过了允许的最大容量
if (oldCap >= MAXIMUM_CAPACITY) {
// 若超过最大容量,表示无法再进行扩容
// 则更新当前的阈值为int的最大值,并返回旧数组
threshold = Integer.MAX_VALUE;
return oldTab;
}
// 将旧容量*2得到新容量,若新容量未超过最大值,并且旧容量大于默认初始容量(16),
// 才则将旧阈值*2得到新阈值
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
// 若不满足上面的oldCap > 0,表示数组还未初始化,
// 若当前阈值不为0,就将数组的新容量记录为当前的阈值;
// 为什么这里的oldThr在未初始化数组的时候就有值呢?
// 这是因为HashMap有两个带参构造器,可以指定初始容量,
// 若你调用了这两个可以指定初始容量的构造器,
// 这两个构造器就会将阈值记录为第一个大于等于你指定容量,且满足2^n的数(可以看看这两个构造器)
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
// 若上面的条件都不满足,表示你是调用默认构造器创建的HashMap,且还没有初始化table数组
else { // zero initial threshold signifies using defaults
// 则将新容量更新为默认初始容量(10)
// 阈值即为(容量*负载因子)
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
// 经过上面的步骤后,newCap一定有值,但是若运行的是上面的第二个分支时,newThr还是0
// 所以若当前newThr还是0,则计算出它的值(容量*负载因子)
if (newThr == 0) {
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
// 将计算出的新阈值更新到成员变量threshold上
threshold = newThr;
// 创建一个记录新数组用来存HashMap中的元素
// 若数组不是第一次初始化,则这里就是创建了一个两倍大小的新数组
@SuppressWarnings({"rawtypes","unchecked"})
HashMap.Node<K,V>[] newTab = (HashMap.Node<K,V>[])new HashMap.Node[newCap];
// 将新数组的引用赋值给成员变量table
table = newTab;
// 开始将原来的数据加入到新数组中
if (oldTab != null) {
// 遍历原数组
for (int j = 0; j < oldCap; ++j) {
HashMap.Node<K,V> e;
// 若原数组的j位置有节点存在,才进一步操作
if ((e = oldTab[j]) != null) {
// 清除旧数组对节点的引用
oldTab[j] = null;
// 若table数组的j位置只有一个节点,则直接将这个节点放入新数组
// 使用 & 替代 % 计算出余数,即下标
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;
// 若第一个节点是一个数节点,表示原数组这个位置的链表已经被转为了红黑树
// 则调用红黑树的方法将节点加入到新数组中
else if (e instanceof HashMap.TreeNode)
((HashMap.TreeNode<K,V>)e).split(this, newTab, j, oldCap);
// 上面两种情况都不满足,表示这个位置是一条不止一个节点的链表
// 以下操作相对复杂,所以在下面数据移动源码中单独拿出来讲解
//所以看不懂的先看下面部分的讲解
else { // preserve order
// 创建两个头尾节点,表示两条链表
// 因为旧链表上的元素放入新数组中,最多将变成两条链表
// 一条下标不变的链表,一条下标+oldCap
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;
// 注意:e.hash & oldCap这一步就是前面说的判断多出的这一位是否为1
// 若与原容量做与运算,结果为0,表示将这个节点放入到新数组中,下标不变
if ((e.hash & oldCap) == 0) {
// 若这是不变链表的第一个节点,用loHead记录
if (loTail == null)
loHead = e;
// 否则,将它加入下标不变链表的尾部
else
loTail.next = e;
// 更新尾部指针指向新加入的节点
loTail = e;
}
// 若与原容量做与运算,结果为1,表示将这个节点放入到新数组中,下标将改变
else {
// 若这是改变下标链表的第一个节点,用hiHead记录
if (hiTail == null)
hiHead = e;
// 否则,将它加入改变下标链表的尾部
else
hiTail.next = e;
// 更新尾部指针指向新加入的节点
hiTail = e;
}
} while ((e = next) != null);
// 所有节点遍历完后,判断下标不变的链表是否有节点在其中
if (loTail != null) {
// 将这条链表的最后一个节点的next指向null
loTail.next = null;
// 同时将其放入新数组的相同位置
newTab[j] = loHead;
}
// 另一条链表与上同理
if (hiTail != null) {
hiTail.next = null;
// 这条链表放入的位置要在原来的基础上加上oldCap
newTab[j + oldCap] = hiHead;
}
}
}
}
}
// 将扩容后数组返回
return newTab;
}
2、数据移动源码
resize
方法中的最后一部分,是将原数组中的一条链表的节点,放入到扩容后的新数组中,主要涉及到链表的拆分
,而这一部分相对来说比较难理解。首先我们得知道是怎么实现的,然后再来逐句分析代码。
首先,我们得知道一个结论,那就是:原数组中一条链表上的所有节点,若将它们加入到扩容后的新数组中,它们最多将会分布在新数组中的两条链表上。两条链表位置为n和n+原数组容量。新假设我们原容量为8,扩容后容量则为16,如果原链表在原数组下标为2的位置,则拆分后在新数组下标为2和下标为10(2+8)的位置。
在HashMap
中,使用按位与运算替代了取模运算来计算下标,因为num % 2^n == num & (2^n - 1)
,而HashMap
的容量一定是2^n
,所以可以使用这条定理(这里我假设大家已经了解了HashMap
的容量机制,若不了解的,可以先看看我最上面给出的那篇博客)。我们看下面这张图,左边是扩容前的数组+链表,右边是扩容后的数组+链表,链表矩形中的数字表示节点的hash
值。左边数组的容量为2^3==8
,只包含一条四个节点的链表,右边数组的容量为2^4 == 16
,左边链表上的节点重新存储后,变成了右边两条链表。正对应了我们上面说的结论。
那这个结论是怎么来的呢?我们先说左边第一个节点,它的hash
值是2
,转换成二进制就是0010
,而容量为2^3 == 8
,通过num % 2^n == num & (2^n - 1)
这个公式,我们知道2
与容量8
的余数是2 & (8 - 1) == 0010 & 0111 == 0010
。任何数与0111做与运算(&),实际上就是取这个数二进制的最后三位。而扩容之后,容量变成了2^4 == 16
,这时候,取模就是与16-1 == 15
做与运算了,而15
的二进制是1111
,我们发现,1111
与之前的0111
唯一的区别就是第四位也变成了1(以下说的第几位都是从右往左)。而2 & 15 == 0010 & 1111 == 0010
,和0010 & 0111
结果是一样的。为什么?因为0010
的第四位是0
,所以从0111
变成1111
,并不会对计算结果造成影响,因为0
和任何数做与运算,结果都是0
。所以扩容后,2
这个节点,还是放在数字下标为2
的位置。我们在来看看剩下的三个数:
hash值为10,转换成二进制1010,1010的第四位为1,所以 1010 & 0111 != 1010 & 1111 hash值为18,转换成二进制10010,10010的第四位为0,所以 10010 & 0111 == 10010 & 1111 hash值为26,转换成二进制11010,11010的第四位为1,所以 11010 & 0111 != 11010 & 1111
所以扩容后,余数是否发生改变,实际上只取决于多出来的那一位而已,那一位只有两种结果:0
或者1
,所以这些节点的新下标最终也只有两种结果。而多出来的那一位是哪一位呢?8
转换成二进制是1000
,而从8
扩容到16
,取余的数从0111
变成了1111
,多出的这个1
刚好在第四位,也就是1000
中,唯一一个1
所在的位置;16
的二进制是10000
,扩容成32
后,取余的数从1111
变成11111
,在第五位多出了一个1
,正好是10000
的1所在的位置。所以我们可以知道,扩容后,节点的下标是否需要发生改变,取决于旧容量的二进制中,1
那一位。所以容量为8
,扩容后,若节点的二进制hash
值的第四位为0
,则节点在新数组中的下标不变;若为1
,节点的下标改变,而且改变的大小正好是+8
,因为多出了最高位的1
,例如1010 & 0111 = 0010
,而1010 & 1111 = 1010
,结果相差1000
,也就是旧容量的大小8
;所以若下标要发生改变,改变的大小将正好是旧数组的容量。
我们如何判断hash
值多出来的那一位是0
还是1
呢,很简单,只要用hash
值与旧容量做与运算,结果不为0
表示多出的这一位是1
,否则就是0。比如说,容量为8
(二进制1000
),扩容后多出来的是第四位,于是让hash
值与1000
做与运算,若hash
值的第四位是1
,与1000
做与运算后结果就是1000
,若第四位是0
,与1000
做与运算后就是0
。好,下面我们来看看代码吧:
// 创建两个头尾节点,表示两条链表
// 因为旧链表上的元素放入新数组中,最多将变成两条链表
// 一条下标不变的链表,一条下标+oldCap
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;
// 注意:e.hash & oldCap这一步就是前面说的判断多出的这一位是否为1
// 若与原容量做与运算,结果为0,表示将这个节点放入到新数组中,下标不变
if ((e.hash & oldCap) == 0) {
// 若这是不变链表的第一个节点,用loHead记录
if (loTail == null)
loHead = e;
// 否则,将它加入下标不变链表的尾部
else
loTail.next = e;
// 更新尾部指针指向新加入的节点
loTail = e;
}
// 若与原容量做与运算,结果为1,表示将这个节点放入到新数组中,下标将改变
else {
// 若这是改变下标链表的第一个节点,用hiHead记录
if (hiTail == null)
hiHead = e;
// 否则,将它加入改变下标链表的尾部
else
hiTail.next = e;
// 更新尾部指针指向新加入的节点
hiTail = e;
}
} while ((e = next) != null);
// 所有节点遍历完后,判断下标不变的链表是否有节点在其中
if (loTail != null) {
// 将这条链表的最后一个节点的next指向null
loTail.next = null;
// 同时将其放入新数组的相同位置
newTab[j] = loHead;
}
// 另一条链表与上同理
if (hiTail != null) {
hiTail.next = null;
// 这条链表放入的位置要在原来的基础上加上oldCap
newTab[j + oldCap] = hiHead;
}
3、扩容操作整体流程图
(四)get方法
1、get方法
public V get(Object key) {
Node<K,V> e;
//获取值,没有返回空
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
2、getNode方法
/**
* get方法的具体实现
*
* @param hash key的hash值
* @param key key
* @return 返回node节点,如果不存在则返回空
*/
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab;
Node<K,V> first, e;
int n;
K k;
//如果当前map数组不为空,并且key的hash值获取到的位置有值
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
//判断第一个节点key是否相等
if (first.hash == hash && // always check first 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 {
//判断下个节点key是否与传入key相等
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
//如果相等则直接返回
return e;
//循环条件为下个节点不为空
} while ((e = e.next) != null);
}
}
//如果数组为空则直接返回空
return null;
}
(五)扩展
1、transient修饰符作用:
- transient关键字只能修饰变量,而不能修饰方法和类。注意,本地变量是不能被transient关键字修饰的。
- 被transient关键字修饰的变量不再能被序列化,一个静态变量不管是否被transient修饰,均不能被序列化。
- 一旦变量被transient修饰,变量将不再是对象持久化的一部分,该变量内容在序列化后无法获得访问。也可以认为在将持久化的对象反序列化后,被transient修饰的变量将按照普通类成员变量一样被初始化。
2、与&、或|、异或^运算规则
- 与&:两位同时为“1”,结果才为“1”,否则为0
- 或|:参加运算的两个对象只要有一个为1,其值为1
- 异或:参加运算的两个对象,如果两个相应位为“异”(值不同),则该位结果为1,否则为0
3、链表与红黑树时间复杂度
链表的时间复杂度是O(n),红黑树的时间复杂度O(logn)。
四、问题
问题1:hashmap为什么不直接就用红黑树呢?
原因1:源码中写到是因为树节点所占空间是普通节点的两倍,所以只有当节点足够多的时候,才会使用树节点。也就是说,节点少的时候,尽管时间复杂度上,红黑树比链表好一点,但是红黑树所占空间比较大,综合考虑,认为只能在节点太多的时候,红黑树占空间大这一劣势不太明显的时候,才会舍弃链表,使用红黑树。
问题2:为什么链表长度大于等于8之后才转成红黑树?
原因2:因为在计算存放位置时已经利用了key的hashCode()和key的hashcode的高16位^(异或)运算,使得整个map的存放更加散列,所以在同一个位置下的链表不会很长,大部分情况下都会进行扩容。其次在理想状态下,受随机分布的hashCode影响,链表中的节点遵循泊松分布,而且根据统计,链表中节点数是8的概率已经接近千分之一,而且此时链表的性能已经很差了。所以在这种比较罕见和极端的情况下,才会把链表转变为红黑树。