hashmap是一种特殊的数据结构,在jdk1.7以及之前,采用拉链法(数组+链表)实现哈希表,在jdk1.8的时候,加入了红黑树的数据结构,提高了散列值冲突情况下的查询效率。
直接看源代码(参考jdk1.8):
1.hashmap是如何存储和查询数据的:
我们都知道要通过put(K key, V value)方法向hashmap中存储键值对,下面我们就从put方法展开,对存储过程进行详细分析:
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
可以看到,put方法非常简单,仅仅是通过return一个putVal的方法调用,在我们分析putVal方法之前,我们注意到还有一个hash(K key)方法,那么我们先来分析这个方法:
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
hash方法是hashmap的核心方法,我们看到这个方法用来计算键key的散列值,是hashmap的散列函数。计算方法非常简单,一个三元操作符就可以完成。key如果为null,那么散列值为0;否则调用key的java.lang.Object.hashCode()函数获得对象key本身的哈希值,将这个哈希值无符号右移16位(转化为二进制,向右移动16位,高位补0),最后将两个数进行异或处理(二进制数相同位,值相同为0,不同为1)作为key真正的散列值返回。
理解了hash()函数之后,我们接下来看这个putVal方法。
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是hashMap的散列桶(就是数组)
//如果在插入此条数据之前哈希表为空,或者哈希表的桶长度为0,那么对哈希表进行扩容处理(resize()方法),n为桶长度。
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//i=(n-1)&hash是根据key对象的散列值,计算该key应该存放的散列桶数组下标(这个key存放在哪个桶中),与此同时,&运算也保证了i的数值不会超过桶长度。
//如果对应的桶不存在Node节点(Node节点用于存储key和value),那么通过newNode()方法就新建一个Node节点。p为连接桶的链表表头节点。
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
//如果对应的桶已经存在Node节点(已经在这个桶存储了Node)
else {
Node<K,V> e; K k;
//如果要插入的hash值和表头p的哈希值相同且两个键值对的键相同(是同一对象或者内容相同),那么e=表头p。
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
//如果p节点是一个红黑树节点类型,那么直接将新的键值对插入到红黑树中
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
//如果p节点是一个普通的Node节点
else {
//否则遍历链表,通过binCount记录链表长度
for (int binCount = 0; ; ++binCount) {
//在链表末尾新建一个Node
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
//如果链表长度>=8,那么通过treeifyBin()方法将这个链表转化为一个红黑树(提高查询效率,O(N)变为O(logN)),然后break跳出循环。
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
//遇到相同的键,break。
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
//p=e,准备进行下一次for循环。
p = e;
}
}
//如果e不为空,证明存在相同的键,检查新旧value值是否相同,并查看是否允许更新旧值或者旧值为null,进行value的更新并返回旧值。
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
//modCount用来实现迭代器的快速失败,添加一个键值对之后要增加size,并通过和阀值threshold对比来决定是否resize()扩容
++modCount;
if (++size > threshold)
resize();
//afterNodeInsertion(boolean evict)是一个空方法体,可以继承HashMap类并覆盖这个方法来决定插入操作完成后应该干什么。
afterNodeInsertion(evict);
return null;
}
putVal方法又牵扯出许多其他的变量和方法,变量分别是:Node,table,TreeNode, TREEIFY_THRESHOLD, threshold方法有:resize(), newNode(), putTreeVal(), treeifyBin()。我们来一一分析这些内容。
先分析Node,static class Node<K,V> implements Map.Entry<K,V> {...},我们知道这个类是一个链表的节点类,里面存放了(final K)key,(V)value,(final int)hash,(Node<K,V>)next这四种数据就可以。
再分析table,table在hashmap中的定义为:transient Node<K,V>[] table;可见table是一个Node数组,transient意味着不能序列化。table是hashmap的散列桶,数组里为null或者存放着链表表头或者红黑树根节点。table的大小一定是2的整数次幂,原因后面会讲到。
TreeNode,也是用来存储key和value的数据结构,只不过从链表形式转化为树节点。
TREEIFY_THRESHOLD定义了每个散列桶结构从链表转换到红黑树的临界值。当链表长度超过这个值得时候,就会从链表转化到红黑树。
threshold,中文意思是阀值,其值为table长度*负载因子(loadFactor,默认值0.75f)。它和size共同决定了是否需要对hashmap进行扩容。一旦size>=threshold,那么就会调用resize()方法扩容。
然后是方法的分析,我们只终点讲解resize()方法,探究hashmap究竟是如何扩容的:
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;//将table存入oldTab中
int oldCap = (oldTab == null) ? 0 : oldTab.length;//oldCap存放oldTab的数组长度
int oldThr = threshold;//oldThr存放oldTab的负载因子threshold
int newCap, newThr = 0;
//如果旧table长度不是零
if (oldCap > 0) {
//如果oldTab(之前的table)的长度已经达到规定的最大容量(2的30次幂),那么无法对这个hashmap进行扩容处理,直接返回之前的table保持原样。
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
//将oldCap左移1位(即*2)并传递给newCap,如果新值<最大容量且旧值>=初始容量(1<<4=16),那么将newThr也左移1位(*2)。
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
//如果oldCap==0且oldThr>0
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
//如果oldCap==oldThr==0,进行初始化
else { // zero initial threshold signifies using defaults
newCap = DEFAULT_INITIAL_CAPACITY;//16
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);//16*0.75f
}
if (newThr == 0) {
float ft = (float)newCap * loadFactor;
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
//重设threshold
threshold = newThr;
//到此为止,我们知道了大多数情况下:newCap=2*oldCap,newThr=2*oldThr
@SuppressWarnings({"rawtypes","unchecked"})
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];//新的散列表容量是原来的2倍
table = newTab;
//将原来的散列表的内容转移到新的散列表中
if (oldTab != null) {
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
//如果旧散列表桶中存在Node节点(即已经存放了键值对)
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
//如果是末节点
if (e.next == null)
//将这个Node转移到新散列表中
newTab[e.hash & (newCap - 1)] = e;
//如果Node是红黑树的根节点
else if (e instanceof TreeNode)
//将根节点转移到新散列表中
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
//如果Node是链表的表头节点,且后面还链接有其他节点
//通过do-while转移这些节点
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;
}
以上就是对resize()方法的详细分析。
接下来我们来分析get(Object Value)方法,有了put方法的铺垫,我们再看get方法会简单很多,因为get方法并不会涉及到hashmap结构的变化:
public V get(Object key) {
Node<K,V> e;
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
//根据hash值和key值来查找value
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab; Node<K,V> first, e; int n; K k;
//table不为空,且table长度不为0,且哈希值对应的散列桶不为空(即桶上已经存储了数据)
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
//如果头结点的hash等于对应Node的hash且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 {
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
} while ((e = e.next) != null);
}
}
return null;
}
最后,我们来讨论一个细节问题:
hashmap的大小为什么是2的次幂(即table.length为什么是2的次幂):因为这样能使Node均匀分布在散列桶中,参考分布函数:table[(table.length-1) & hash],关键是&运算,2的次幂保证了进行-1操作之后的结果一定的单数,即二进制码的最后一位一定是XXXX XXX1的形式(X可以是0,也可以是1),这样就保证了&运算的结果有可能是单数,有可能是双数。如果不是2的次幂,有可能出现-1操作之后的二进制码是XXXX XXX0的情况,这样进行&运算的时候,导致最终结果一定是偶数,即键值对总会被分布到偶数桶中,导致哈希表利用率低下。