put函数源码解析
//put函数入口,两个参数:key和value
public V put(K key, V value) {
/*下面分析这个函数,注意前3个参数,后面
2个参数这里不太重要,因为所有的put
操作后面的2个参数默认值都一样 */
return putVal(hash(key), key,
value, false, true);
}
//下面是put函数的核心处理函数
final V putVal(int hash, K key, V value
, boolean onlyIfAbsent
,boolean evict) {
Node<K,V>[] tab; Node<K,V> p;
int n, i;
/*上面提到过HashMap是懒加载,所有
put的时候要先检查table数组是否已经
初始化了,没有初始化得先初始化table
数组,保证table数组一定初始化了 */
if ((tab = table) == null
|| (n = tab.length) == 0)
//这个函数后面有resize函数分析
n = (tab = resize()).length;
/*到这里表示table数组一定初始化了
与上面get函数相同,指定key的Node,
会存储在在table数组的i=(n-1)&hash
下标位置,get的时候也是从table数组
的该位置搜索 */
if ((p = tab[i = (n - 1) & hash])
== null)
/*如果i位置还没有存储元素,则把
当前的key,value封装为Node,
存储在table[i]位置 */
tab[i] = newNode(hash, key
, value, null);
else {
//下面部分代码接上这部分
}
接上面else部分:
/*
如果table[i]位置已经有元素了,
则接下来的流程是:
首先判断链表或者二叉树中是否
已经存在key的键值对?
存在的话就更新它的value;不存在
的话把当前的key,value插入到
链表的末尾或者插入到红黑树中
如果链表或者红黑树中已经存在
Node.key等于key,则e指向该Node,
即e指向一个Node:该Node的key属性
与put时传入的key参数相等的那个Node,
后面会更新e.value
*/
Node<K,V> e; K k;
/*
为什么get和put先判断p.hash==hash,
下面的if条件中去掉hash的比较逻辑
也是正确?因为hash的比较是两个整数
的比较,比较的代价相对较小,key是泛型,
对象的比较比整数比较代价大,所以先比较
hash,hash相等再比较key
*/
if(p.hash == hash &&
((k = p.key) == key
|| (key != null
&& key.equals(k))))
/*
e指向一个Node:该Node的key
属性与put时传入的key参数相等
的那个Node
*/
e = p;
else if (p instanceof TreeNode)
/*
红黑树的插入操作,如果已经存在
该key的TreeNode,则返回该
TreeNode,否则返回null
*/
e = ((TreeNode<K,V>)p)
.putTreeVal(this
, tab, hash, key, value);
else {
/*
table[i]处存放的是链表,接下来和
TreeNode类似在遍历链表过程中先判断
当前的key是否已经存在,如果存在则令
e指向该Node;否则将该Node插入到链
表末尾,插入后判断链表长度是否>=8,
是的话要进行额外操作
*/
//binCountt最后的值是链表的长度
for (int binCount = 0;
;++binCount) {
if ((e = p.next) == null) {
/*
遍历到了链表最后一个元素,接下来
执行链表的插入操作,先封装为Node,
再插入p指向的是链表最后一个节点,
将待插入的Node置为p.next,
就完成了单链表的插入
*/
p.next = newNode(hash, key
, value, null);
if (binCount
>= TREEIFY_THRESHOLD - 1)
/*
TREEIFY_THRESHOLD值是8,
binCount>=7,然后又插入了一个新节
点,链表长度>=8,这时要么进行扩容
操作,要么把链表结构转为红黑树结构。
我们接下会分析treeifyBin的源码实现
*/
treeifyBin(tab, hash);
break;
}
/*
当p不是指向链表末尾的时候:先判断
p.key是否等于key,等于的话表示
当前key已经存在了,令e指向p,
停止遍历,最后会更新e的value;
不等的话准备下次遍历,
令p=p.next,即p=e。
*/
if (e.hash == hash &&
((k = e.key) == key
|| (key != null
&& key.equals(k))))
break;
p = e;
}
}
if (e != null) {
/*
表示当前的key在put之前已经
存在了,并且上面的逻辑保证:
e已经指向了之前已经存在
的Node,这时更新
e.value就好。
*/
//更新oldvalue
V oldValue = e.value;
/*
onlyIfAbsent默是false,
evict为true。
onlyIfAbsent为true表示:
如果之前已经存在key这个键值对了,
那么后面再put这个key时,忽略这个
操作,不更新先前的value。
这里了解就好
*/
if (!onlyIfAbsent
|| oldValue == null)
//更新e.value
e.value = value;
/*
这个函数的默认实现是“空”,
即这个函数默认什么操作都
不执行,那为什么要有它呢?
这其实是个hook/钩子函数,
主要要在LinkedHashMap
(HashMap子类)中使用,
LinkedHashMap重写了这
个函数。以后会有讲解
LinkedHashMap的文章。
*/
afterNodeAccess(e);
//返回旧的value
return oldValue;
}
}
//如果是第一次插入key这个键,
//就会执行到这里
++modCount;//failFast机制
/*
size保存的是当前HashMap中保存
了多少个键值对,HashMap的size
方法就是直接返回size之前说过,
threshold保存的是当前table数
组长度*loadfactor,如果table
数组中存储的Node数量大于
threshold,这时候会进行扩容,
即将table数组的容量翻倍。
后面会详细讲解resize方法。
*/
if (++size > threshold)
resize();
//这也是一个hook函数,作用和
//afterNodeAccess一样
afterNodeInsertion(evict);
return null;
}
(11)treeifyBin源码解析
//将链表转换为红黑树结构,在链表的
//插入操作后调用
final void treeifyBin
(Node<K,V>[] tab
, int hash) {
int n, index;
Node<K,V> e;
/*MIN_TREEIFY_CAPACITY值
是64,也就是当链表长度>8的
时候,有两种情况:如果table
数组的长度<64,此时进行扩容
操作;如果table数组的长度>64,
此时进行链表转红黑树结构的操作.
具体转细节在面试中几乎没有问的,
这里不细讲了,大部同学认为链表长度
>8一定会转换成红黑树,这是不对的!
*/
if (tab == null ||
(n = tab.length)
< MIN_TREEIFY_CAPACITY)
resize();
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);
if ((tab[index] = hd) != null)
hd.treeify(tab);
}
}
HashMap的resize函数源码分析
重点中的重点,面试谈到HashMap必考resize相关知识,整体思路介绍:
有两种情况会调用当前函数:
1.之前说过HashMap是懒加载,第一次hHashMap的put方法的时候table还没初始化,这个时候会执行resize,进行table数组的初始化,table数组的初始容量保存在threshold中(如果从构造器中传入的一个初始容量的话),如果创建HashMap的时候没有指定容量,那么table数组的初始容量是默认值:16。即,初始化table数组的时候会执行resize函数
2.扩容的时候会执行resize函数,当size的值>threshold的时候会触发扩容,即执行resize方法,这时table数组的大小会翻倍。
注意我们每次扩容之后容量都是翻倍( *2),所以HashMap的容量一定是2的整数次幂,那么HashMap的容量为什么一定得是2的整数次幂呢?(面试重点)。
要知道原因,首先回顾我们put key的时候,每一个key会对应到一个桶里面,桶的索引是这样计算的: index = hash & (n-1),index的计算最为直观的想法是:hash%n,即通过取余的方式把当前的key、value键值对散列到各个桶中;那么这里为什么不用取余(%)的方式呢?
原因是CPU对位运算支持较好,即位运算速度很快。另外,当n是2的整数次幂时:hash&(n-1)与hash%(n-1)是等价的,但是两者效率来讲是不同的,位运算的效率远高于%运算。
基于上面的原因,HashMap中使用的是hash&(n-1)。这还带来了一个好处,就是将旧数组中的Node迁移到扩容后的新数组中的时候有一个很方便的特性:
HashMap使用table数组保存Node节点,所以table数组扩容的时候(数组扩容一定得是先重新开辟一个数组,然后把就数组中的元素重新散列(rehash)到新数组中去。
这里举一个例子来来说明这个特性:下面以Hash初始容量n=16,默认loadfactor=0.75举例(其他2的整数次幂的容量也是类似的),默认容量:n=16,二进制:10000;n-1:15,n-1二进制:01111。某个时刻,map中元素大于16*0.75=12,即size>12。此时会发生扩容,即会新建了一个数组,容量为扩容前的两倍,newtab,len=32。
接下来我们需要把table中的Node搬移(rehash)到newtab。从table的i=0位置开始处理,假设我们当前要处理table数组i索引位置的node,那这个node应该放在newtab的那个位置呢?下面的hash表示node.key对应的hash值,也就等于node.hash属性值,另外为了简单,下面的hash只写出了8位(省略的高位的0),实际上hash是32位:node在newtab中的索引:
index = hash % len=hash & (len-1)
=hash & (32 - 1)=hash & 31
=hash & (0x0001_1111);
再看node在table数组中的索引计算:
i = hash & (16 - 1) = hash & 15
= hash & (0x0000_1111)。
注意观察两者的异同:
i = hash&(0x0000_1111);
index = hash&(0x0001_1111)
上面表达式有个特点:
index = hash & (0x0001_1111)
= hash & (0x0000_1111)
| hash & (0x0001_0000)
= hash & (0x0000_1111) | hash & n)
= i + ( hash & n)
什么意思呢:
hash&n要么等于n要么等于0;也就是:inde要么等于i,要么等于i+n;再具体一点:当hash&n==0的时候,index=i;
当hash&n==n的时候,index=i+n;这有什么用呢?当我们把table[i]位置的所有Node迁移到newtab中去的时候:
这里面的node要么在newtab的i位置(不变),要么在newtab的i+n位置;也就是我们可以这样处理:把table[i]这个桶中的node拆分为两个链表l1和类:如果hash&n==0,那么当前这个node被连接到l1链表;否则连接到l2链表。这样下来,当遍历完table[i]处的所有node的时候,我们得到两个链表l1和l2,这时我们令newtab[i]=l1,newtab[i+n]=l2,这就完成了table[i]位置所有node的迁移/rehash,这也是HashMap中容量一定的是2的整数次幂带来的方便之处。
下面的resize的逻辑就是上面讲的那样。将table[i]处的Node拆分为两个链表,这两个链表再放到newtab[i]和newtab[i+n]位置.
(12)resize方法源码解析
final Node<K,V>[] resize() {
//保留扩容前数组引用
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null)
? 0 : oldTab.length;
int oldThr = threshold;
int newCap, newThr = 0;
if (oldCap > 0) {
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
//正常扩容:newCap = oldCap << 1
else if ((newCap = oldCap << 1)
< MAXIMUM_CAPACITY
&& oldCap
>= DEFAULT_INITIAL_CAPACITY)
//容量翻倍,扩容后的threshold
//自然也是*2
newThr = oldThr << 1;
}
else if (oldThr > 0)
// initial capacity was placed
//in threshold
newCap = oldThr;
else {
// zero initial threshold
//signifies using defaults
//table数组初始化的时候会进入到这里
//默认容量
newCap = DEFAULT_INITIAL_CAPACITY;
//threshold
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;//更新threshold
@SuppressWarnings({"rawtypes"
,"unchecked"})
//扩容后的新数组
Node<K,V>[] newTab = (Node<K,V>[])
new Node[newCap];
table = newTab;//执行容量翻倍的新数组
if (oldTab != null) {
//之后完成oldTab中Node迁移到table中去
//见下面
}
}
}
return newTab;
}
}
//之后完成oldTab中Node迁移到table中去
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
if (e.next == null)
/*j这个桶位置只有一个元素,直接
rehash到table数组 */
newTab[e.hash
& (newCap - 1)] = e;
else if (e instanceof TreeNode)
/*如果是红黑树:也是将红黑树拆分为
两个链表,这里主要看链表的拆分,
两者逻辑一样*/
((TreeNode<K,V>)e).split(
this, newTab, j, oldCap);
else {
//链表的拆分
//第一个链表l1
Node<K,V> loHead = null
, loTail = null;
//第二个链表l2
Node<K,V> hiHead = null
, hiTail = null;
Node<K,V> next;
do {
next = e.next;
if ((e.hash & oldCap)
== 0) {
/*rehash到table[j]位置
将当前node连接到l1上 */
if (loTail == null)
loHead = e;
else
loTail.next = e;
loTail = e;
}
else {
//将当前node连接到l2上
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
if (loTail != null) {
//l1放到table[j]位置
loTail.next = null;
newTab[j] = loHead;
}
if (hiTail != null) {
//l1放到table[j+oldCap]位置
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
HashMap面试“明星”问题汇总,及答案
你知道HashMap吗,请你讲讲HashMap?
这个问题不单单考察你对HashMap的掌握程度,也考察你的表达、组织问题的能力。个人认为应该从以下几个角度入手(所有常见HashMap的考点问题总结):
size必须是2的整数次方原因
get和put方法流程
resize方法
影响HashMap的性能因素(key的hashCode函数实现、loadFactor、初始容量)
HashMap key的hash值计算方法以及原因(见上面hash函数的分析)
HashMap内部存储结构:Node数组+链表或红黑树
table[i]位置的链表什么时候会转变成红黑树(上面源码中有讲)
HashMap主要成员属性:threshold、loadFactor、HashMap的懒加载
HashMap的get方法能否判断某个元素是否在map中
HashMap线程安全吗,哪些环节最有可能出问题,为什么?
HashMap的value允许为null,但是HashTable和ConcurrentHashMap的valued都不允许为null,试分析原因?
HashMap中的hook函数(在后面讲解LinkedHashMap时会讲到,这也是面试时拓展的一个点)
上面问题的答案都可以在上面的源码分析中找到,下面在给三点补充:
HashMap的初始容量是怎样影响HashMap的性能的?
假如你预先知道最多往HashMap中存储64个元素,那么你在创建HashMap的时候:如果选用无参构造器:默认容量16,在存储16loadFactor个元素之后就要进行扩容(数组扩容涉及到连续空间的分配,Node节点的rehash,代价很高,所以要尽量避免扩容操作);如果给构造器传入的参数是64,这时HashMap中在存储64loadFactor个元素之后就要进行扩容;但是如果你给构造器传的参数为:(int)(64/0.75)+1,此时就可以保证HashMap不用进行扩容,避免了扩容时的代价。
HashMap线程安全吗,哪些环节最有可能出问题,为什么?
我们都知道HashMap线程不安全,那么哪些环节最优可能出问题呢,及其原因:没有参照这个问题有点不好直接回答,但是我们可以找参照啊,参照:ConcurrentHashMap,因为大家都知道HashMap不是线程安全的,ConcurrentHashMap是线程安全的,对照ConcurrentHashMap,看看ConcurrentHashMap在HashMap的基础之上增加了哪些安全措施,这个问题就迎刃而解了。后面会有分析ConcurrentHashMap的文章,这里先简要回答这个问题:HashMap的put操作是不安全的,因为没有使用任何锁;HashMap在多线程下最大的安全隐患发生在扩容的时候,想想一个场合:HashMap使用默认容量16,这时100个线程同时往HashMap中put元素,会发生什么?扩容混乱,因为扩容也没有任何锁来保证并发安全,另外,后面的博文会讲到ConcurrentHashMap的并发扩容操作是ConcurrentHashMap的一个核心方法。
HashMap的value允许为null,但是HashTable和ConcurrentHashMap的value 都不允许为null,试分析原因?
首先要明确ConcurrentHashMap和Hashtable从技术从技术层面讲是可以允许value为null;但是它是实际是不允许的,这肯定是为了解决一些问题,为了说明这个问题,我们看下面这个例子(这里以ConcurrentHashMap为例,HashTable也是类似)。
HashMap由于允value为null,get方法返回null时有可能是map中没有对应的key;也有可能是该key对应的value为null。所以get不能判断map中是否包含某个key,只能使用contains判断是否包含某个key。
看下面的代码段,要求完成这个一个功能:如果map中包含了某个key则返回对应的value,否则抛出异常:
if (map.containsKey(k)) {
return map.get(k);
} else {
throw new KeyNotPresentException();
}
如果上面的map为HashMap,那么没什么问题,因为HashMap本来就是线程不安全的,如果有并发问题应该用ConcurrentHashMap,所以在单线程下面可以返回正确的结果
如果上面的map为ConcurrentHashMap,此时存在并发问题:在map.containsKey(k)和map.get之间有可能其他线程把这个key删除了,这时候map.get就会返回null,而ConcurrentHashMap中不允许value为null,也就是这时候返回了null,一个根本不允许出现的值?
但是因为ConcurrentHashMap不允许value为null,所以可以通过map.get(key)是否为null来判断该map中是否包含该key,这时就没有上面的并发问题了。