HashMap的基本原理
HashMap根据key通过hash函数计算出hash值直接就可以定位key所在位置,时间复杂度为O(1),不同的key可能计算出相同的hash值,会产生冲突,发生冲突时,可以通过链地址法解决,就是在冲突的节点上延申出去一条链,通过hash函数定位到节点key跟查找的key不相等时,继续节点延申出来这条链去检索。
HashMap结构图:
hash函数:key%10
冲突处理:链地址法
以上简述了HashMap的基本原理,设计实现出一个性能好的HashMap却不容易,参考一下几个问题:
1、hash函数的设计
hash函数要尽量将key分散开,假设最坏情况,hash函数产生值是固定不变的,永远返回0,那么所有节点都还放在0号节点这个桶里面,也就退化成一条链做顺序查找,因此hash函数要能够将key尽量分散开,尽量保证分散各个桶的key数量差不多,才能有效利用hash函数进行查找。
2、如何确定hash表的容量
HashMap通过hash函数可以直接计算出在数组上的位置,初始容量(指数组的长度)多少比较合适呢?假设有10万个key容量为10,就算数据分布完全均匀,每个桶里面也包含了1万key,经过hash后还是需要进行大量查找,反过来假设容量为1万,key只有10个,就存在大量空间浪费,因此,容量跟数据量成正比,如果根本不确定数据量有多少,那还会涉及数组长度调整。
3、hash表容量调整后需要重新计算hash
hash表的容量调整后,需要重新计算hash,按新的容量重新计算数据分布,调整一次需要很大的计算量。
实现一个性能好的HashMap并容易,带着上面的问题,来看一下JDK 里面的HashMap是如何实现的。
HashMap的构造函数
/** 初始化容量和装载因子 */
public HashMap(int initialCapacity, float loadFactor);
/** 初始化容量*/
public HashMap(int initialCapacity);
/** 用默认容量和默认装载因子 */
public HashMap();
/** 通过Map对象初始化,默认装载因子 */
public HashMap(Map<? extends K, ? extends V> m);
主要看构造函数里面的两个参数
参数 | 用途 | 默认值 |
---|---|---|
initialCapacity(初始容量) | 就是数组的初始长度,必定是2的整数次幂,如16、32,如果传入的不是2的整数次幂,则自动向上去,例如传入29,30实际上长度都会用32 | 16 |
loadFactor (装载因子) | 触发扩容的阈值,当(实际元素个数/当前容量)> 装载因子 时,HashMap会进行扩容 | 0.75 |
HashMap相关结构体
从源码中复制出来的字段
class HashMap{
// 一维数组
transient Node<K,V>[] table;
// 遍历HashMap的Set视图,和HashMap共享数据节点的,遍历过一次后就会生成,下次遍历时直接从属性中取
transient Set<Map.Entry<K,V>> entrySet;
// 元素个数
transient int size;
// 统计修改次数,用于实现快速失败,当遍历的时候去增加删除HashMap元素会抛出异常
transient int modCount;
// 下一次的扩容的容量
int threshold;
// 装载因子
final float loadFactor;
}
/** 链表节点 */
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> next;
}
/** 红黑树节点 */
static final class TreeNode<K,V> extends LinkedHashMap.Entry<K,V> {
TreeNode<K,V> parent; // red-black tree links
TreeNode<K,V> left;
TreeNode<K,V> right;
TreeNode<K,V> prev; // needed to unlink next upon deletion
boolean red;
}
JDK中的HashMap也是采用链地址法解决冲突,元素少时用单向链表,元素多时用红黑树,单个桶内元素个数达到8时,就从将链表转换成红黑树进行存储。
HashMap实现
hash值计算和根据hash值计算在数组中的位置
通过key对象的hashCode计算hash:
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
通过hash计算元素在数组上的位置:
// n = tab.length
Node p = tab[i = (n - 1) & hash];
hash值是通过key的hashCode和hashCode的高16位右移到低16位后按位与得到hash值。
容量减1再和hash按位与得到在tab中的位置。
问题1:为什么要用容量减1后再和hash值按位与?为什么容量一定是2的整数幂
容量是2的整数次幂,拿8位数来说,2的二进制为10,4的二进制为100,8的二进制为1000,
8-1的二进制为0111,用0111和其他数按位与运算得到数范围再[0-7]刚好是数组的下标,运算简单高效。
问题2:为什么要将高16位移动到低16位作再按位与呢?
因为计算元素在数组上的位置时,是按位与的,在容量比较少时,只用到低位进行与运算,高位对计算没有影响,所以将高位的影响也传递到地位,这样hash值得高16位在容量比较时也能对位置产生影响。
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;
if (oldCap > 0) {
// 当前容量已经达到最大值时,不在进行扩容
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
// 新的容量翻倍
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
// 构造函数传入容量一开始会放在threshold中,当前容量为0,使用构造方式的初始化容量参数初始化
else if (oldThr > 0) // initial capacity was placed in threshold
newCap = oldThr;
else { // zero initial threshold signifies using defaults
// 使用默认参数初始化
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
// 计算下一次扩容的阈值,到达thr后进行扩容
if (newThr == 0) {
float ft = (float)newCap * loadFactor; // 容量达到ft时进行扩容
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
threshold = newThr;
// 容量增长后,需要重新计算元素的hash
@SuppressWarnings({"rawtypes","unchecked"})
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
if (oldTab != null) {
// 遍历数组中的所有bin
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;
if (e.next == null) // bin里面只有一个节点
newTab[e.hash & (newCap - 1)] = e;
else if (e instanceof TreeNode) // bin里面是一棵红黑树
// 将红黑树拆分到两个bin里面
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else { // preserve order // bin里面是链表
// 拆成两条链表
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;
}
每次增长容量都将容量翻倍,扩容后需要将原有节点重新分配新的bin(桶)内,旧的节点时在分配在新的数组上两个位置,假设旧的的容量时8,那计算位置时跟111按位与,新的容量为16,跟1111按位与,计算结果的低三位肯定是一样的,不相同的只可能有一位,所以只能分配到两个位置,新加入到按位与的高位为0时数组序号和原来的相等,为1拆分到新增的高位的bin(桶)内,并且每次拆分到新的数组用到的两个bin是互不重叠的。
总结
JDK中HashMap的hash函数设计非常巧妙,容量取2的整数次幂,容量减1后刚好可以将低位全部充填为1,然在再与hash值按位与,刚好能得到数组的下标,不用检查数组是否越界。hashCode的高16位右移到低16位生成hash值,将高位的影响传递到地位,保证当容量比较小时,高位也能对hash运算产生影响。在这种按位与计算元素所在位置方式,hash进行扩容时,也能刚好将原来在同一个bin的元素拆分到新的两个bin中,并且不会重叠。