提起HashMap,开发界可谓无人不知,无人不晓。但是在面试中,HashMap相关的问题往往却是开发人员最熟悉的陌生人。
应该拿什么拯救你,我的HashMap?
别慌,接下来由我给你全面深入HashMap的原理,最后再附送常见面试题总结小彩蛋,方面大家检测自己的理解水平。(由于目前主流的JDK版本都是JDK1.8,因此本文也是在JDK1.8的基础上进行源码分析。)
首先我要告诉你们,想要掌握HashMap,只需掌握以下几个方面的知识点:HashMap的实现,PUT方法,GET方法,扩容即可,是不是瞬间就提神了。
实现原理:
HashMap的实现:无论是1.7还是1.8,HashMap的实现都是通过数组(主体)+链表的形式,也被称为(拉链法),只是在JDK1.8之后新增了红黑树的组成结构。至于为什么用数组+链表,1.8为什么又要用红黑树,什么时候会用到红黑树,是不是有面试内味了(狗头),待我一一陈述。
HashMap是什么:HashMap使用一个Entry数组保存Key,Value数据。当键值存入数组前,将key通过哈希算法计算出哈希值,将该值作为数组的下标index,然后把下标index对应的位置作为键值对的存储位置,通过这种方法建立的数组就叫做HashMap,而这个存储位置就叫做桶(bucket)。
哈希冲突(也叫哈希碰撞):在计算哈希值作为数组下标时,可能存在不同的key会得到相同结果的情况,也就是插入元素的时候发现已经被其他元素占位了。这种情况被称为哈希冲突。我们的第一个问题就从这里引入。
解决哈希冲突的方法有拉链法,开放定址法(发生冲突,继续寻找下一块未被占用的存储地址)。在HashMap中采用的是拉链法(链表+数组):如果存在哈希冲突的情况下,会在数组下标index的位置生成链表,将冲突的值加入到链表中。由此可见数组才是HashMap的主体,链表则是为了解决哈希冲突而存在的。
接下来到源码分析部分了,首先上菜的是字段解释,这一部分扫一眼留点印象就好啦:
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
默认数组初始化值,必须为2的幂。这里的2的幂可以减少哈希冲突。在这里可以看到后面注释AKA16,为什么不直接写16,也是因为在计算机计算中位移运算效率更高。
说明:initialCapacity = (需要存储的元素个数/加载因子)+1
这里有一个小建议:在初始化HashMap的时候,应该尽量指定其大小。尤其是当你已知map中存放的元素个数时。(《阿里巴巴Java开发规约》)
static final int MAXIMUM_CAPACITY = 1 << 30;
最大的数组长度为2^30。
final float loadFactor;
加载因子。
static final float DEFAULT_LOAD_FACTOR = 0.75f;
默认加载因子。
static final int TREEIFY_THRESHOLD = 8
表示在扩容时,如果链表长度小于6,则由树退化成单链,这样能避免频繁的触发类型转带来的性能开销。
static final int UNTREEIFY_THRESHOLD = 6;
表示链表长度大于阈值(默认为8)的时候,将链表转化为红黑树。
static final int MIN_TREEIFY_CAPACITY = 64;
最小树化容量:当哈希表中容量>该值(64)的时候,才允许从链表转向树形结构,这里有两个点值得注意:
1.若hash表的大小很小的时候,表所需空间还不多,可以牺牲空间减少时间。但当元素太多时,则直接扩容,而不是树形化。
2.为了避免进行扩容、树形化选择的冲突,这个值不能小于 4 * TREEIFY_THRESHOLD。
int threshold:
HashMap内能容纳的键值对的个数。如果table还没有被初始化,threshold中保存的是initialCapacity(即table的初始化大小),或者为0(DEFAULT_INITIAL_CAPACITY),当存储的键值对个数>threshold时,HashMap将会扩容。计算该值的方法:threshold = table.length * loadFactor。
transient int modCount;
记录修改次数,用于记录内部结构变化的次数。
PUT方法
好的,下面就来看PUT方法,在JDK1.8中,PUT方法调用了putVal,让我们来研究这个putVal方法:
//首先看参数:hash,key,value,onlyIfAbsent,evict,数一数前面三个还好,后面两个是什么鬼?先不管了,用小本本记下来。
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
Node<K,V>[] tab; Node<K,V> p; int n, i;
//【1】首先判断结点数组是否为null或者结点数为0,如果为空则扩容
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//【2】如果首结点的值为null,则创建一个新的结点。((n-1)&hash保证了查找位置不会大于数组长度)
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
//【3】处理哈希冲突
else {
Node<K,V> e; K k;
//【4】如果在首节点存在与待插入元素相同的hash和key值,则先用变量e记录该键值。
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
//【5】如果首节点的类型是树状结构,说明采用的是数组+红黑树的方法存储该值,这里不对putTreeVal作深究
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
//【6】到了这一步表示key不相同,只是hash冲突,且首结点类型为链表。
else {
for (int binCount = 0; ; ++binCount) {
if ((e = p.next) == null) {
//【7】在尾部插入新结点,即“尾插法”
p.next = newNode(hash, key, value, null);
//【8】结点数量到达TREEIFY_THRESHOLD,转化为红黑树
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
//【9】判断链表中结点的key值与插入元素的key值是否相等
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
//【10】hsah值,key值相等,跳出循环
break;
//【11】否则将next值赋值给P,结合前面用到的e=p.next可以实现遍历桶中的链表
p = e;
}
}
//【12】e!=null表示在桶中找到key值,hash值与插入元素相等的结点,下面非粗体注释为源码自带
if (e != null) { // existing mapping for key
//【13】取出该结点的值,如果 或者值为空
V oldValue = e.value;
//【14】这里的onlyIfAbsent有点眼熟,不就是一开始putVal方法传入的第四个参数。现在解释就好懂多了:若onlyIfAbsent的值为true,即使插入元素的key已经存在,也不会替换value。
当onlyIfAbsent 是false,且key对应的旧值不为null则插入的新值替换旧值。
这里就根据实际情况传入onlyIfAbsent 啦。
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
//【15】最后再返回被替换掉的值。
return oldValue;
}
}
//【16】如果e=null,则记录修改次数,主要是对Map的Iterator()操作做一致性校验。在使用Iterator迭代器时会和这个变量比较,如果不相等,则会抛出ConcurrentModificationException异常
++modCount;
//【17】遍历完成,修改次数modCount+1,因为前面尾插法添加一个结点,所以size也+1,如果size大于阈值则扩容
if (++size > threshold)
resize();
//【18】传说中的第五个参数evict,然而afterNodeInsertion是个空方法,所以evict在这里没啥作用-。-
afterNodeInsertion(evict);
return null;
}
让我们梳理一下PUT方法的过程:
1.如果初始结点数组为null或者结点数量=0,则用resize方法重置(【1】)
2.计算索引位置,如果为null,则新增结点(【2】)
3.插入元素位于首结点(【4】)
4.用链表或者红黑树的方法插入节点(【5-11】)
扩容
前面多次提到扩容,也应该对扩容做点分析:
//【1】可以用来初始化HashMap大下,或者使HashMap大小变为原来的2倍
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) {
//【2】超过1>>30大小,无法扩容,只能改变阈值
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
//【3】新的容量为旧的2倍,最小也是16
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
//【4】扩容阈值加倍
newThr = oldThr << 1; // double threshold
}
//【5】此时oldcap=0,oldThr>0
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
//【6】此时oldcap=0.oldThr=0,即使用默认加载因子+初始容量进行初始化
else { // zero initial threshold signifies using defaults
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"})
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
//【7】区分红黑树和链表进行添加
table = newTab;
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode)
((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;
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;
}
梳理一下扩容方法的需要注意的地方:
1.扩容后大小是扩容前的2倍。
2.从旧table迁移到新table需要重新hash,减少哈希冲突。
GET方法
接下来也该轮到GET方法了吧:
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
在GET方法中调用了getNode方法,也让我们继续看下去:
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
//【1】首先判断tab数组不为空且length>0,且key的hash对应的第一个元素不为空,才继续下面,否则直接到最后return null;
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
//【2】接下来判断tab[i]的首个元素是否和key一样,如果相同那就是第一个值,直接返回该value
if (first.hash == hash && // always check first node
((k = first.key) == key || (key != null && key.equals(k))))
return first;
if ((e = first.next) != null) {
//【3】判断如果是红黑树结构,则从树中查找数据并返回
if (first instanceof TreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
//【4】这里的do-while结构表示当不为红黑树结构,则遍历链表直到节点的value和key值相等,并返回
do {
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}
同样地,我们对GET方法也做一个总结:
1.首先判断table是否为空,并根据hash值算出当前索引下的node是否为空
2.如果table的首个元素hash值相等,key值也一样,那就是第一个值,则返回该value
3.如果第一个元素的hash值和key值不相等,先判断首元素是否是红黑树节点,如果是则去红黑树中查找;反之去链表中查找,直到节点的key和value值相等,则返回。
关于HashMap的介绍到这里就结束了。最后附带点问题课后自测一下:
1.HashMap的内部数据结构?
2.HashMap中是如何减少哈希冲突的?
3.说说头插法/尾插法的区别?
4.HashMap的初始长度是多少?什么?选择2的幂和杨幂有什么关系?
5.HashMap的PUT/GET流程?
6.HashMap的扩容流程?加载因子为什么默认是0.75f?扩容流程在JDK1.7与JDK1.8中有什么区别?
7.HashMap是否线程安全,为什么,解决方法是什么?
8.红黑树什么时候用到,为什么不一直用?