HashMap
HashMap原理讲解
原理:
HashMap是由数据+链表+红黑树的形式组成的
数组:是一块连续的存储空间,存储的每一个元素都有自己的下标
优点:寻址容易,通过下标可以快速的访问到元素,索引速度快
缺点:大小固定,数组中的空间放满了,需要重新建立新数组,复制原有数组到新数组中,并且插入和删除困难
链表:每一个元素存储下一个元素的内存地址,链式存储,存储元素离散
优点:添加元素快速,只需要将上一个元素指向自己,自己存储下一个元素的地址,插入和删除容易
缺点:没有索引下标,寻址困难,每次查找元素都需要从头部从新遍历,依次查找
HashMap底层的数据结构是hash散列表,结合了数组+链表两种数据结构。既满足了数组的查找方便,也不需要占用太大的内存空间。
采用Node(继承自Entry)数组来存储key-value的键值对,一个Node对应一个键值对,Node类是一个单向链表的结构,
通过next(Node类型)指针连接下一个Node节点(解决hash冲突问题)。
Node是HashMap的一个静态内部类,有key,value,hash,next是个属性。
key,value即存储的是每个节点的键值对,
hash 存储对应节点的hash值(并不是key的直接hash,而是(h = key.hashCode()) ^ (h >>> 16),后边会对此方法详细讲解)
next 是一个指针,用来记录下一个元素
当链表的长度超过8并且数组长度超过64之后链表将会转换为红黑树结构
如图:
HashMap相关属性介绍
HashMap中的几个重要属性如下:
/**
*
* 缺省的table容量(不指定的话为16),必须是2的幂
*/
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
/**
*
* table的最大容量,必须是2的幂
*/
static final int MAXIMUM_CAPACITY = 1 << 30;
/**
*
* 默认的负载因子(不指定的话为0.75)
*/
static final float DEFAULT_LOAD_FACTOR = 0.75f;
/**
*
* 链表转为红黑树的阈值,代表的是链表长度的阈值
*/
static final int TREEIFY_THRESHOLD = 8;
/**
*
* 红黑树降级为链表的阈值,代表的是链表长度的阈值
*/
static final int UNTREEIFY_THRESHOLD = 6;
/**
*
* 链表转为红黑树的阈值,代表的是哈希表数组长度(超过64)
*/
static final int MIN_TREEIFY_CAPACITY = 64;
/**
*
* 哈希表
*/
transient Node<K,V>[] table;
/**
*
* 当前hash表的元素个数
*/
transient int size;
/**
*
* 当前哈希表的结构修改次数(元素的添加,删除,数组的扩容会修改此值,元素的替换不会修改)
*/
transient int modCount;
/**
*
* 扩容阈值,当哈希表中的元素超过阈值时,触发扩容
*
*/
int threshold;
/**
*
* 负载因子
* threshold = capacity * loadFactor
*
*/
final float loadFactor;
构造方法源码解析
HashMap中有四个构造方法:
-
两个参数的构造方法: initialCapacity 初始的哈希表长度,loadFactor 负载因子
HashMap(int initialCapacity, float loadFactor); -
一个参数的构造方法,其实调的还是两个参数的构造方法
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
- 无参构造 构造一个具有默认初始容量 (16) 和默认负载因子 (0.75) 的空HashMap
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
- 使用与指定Map相同的映射构造一个新的HashMap 。 HashMap是使用默认负载因子 (0.75) 创建的,初始容量足以在指定的Map 中保存映射。
参数:m – 要在此地图中放置其映射的地图HashMap(Map<? extends K, ? extends V> m)
public HashMap(Map<? extends K, ? extends V> m) {
this.loadFactor = DEFAULT_LOAD_FACTOR;
putMapEntries(m, false);
}
其实搞懂了两个参数的构造方法,其他的都很好理解,而且两个参数的构造方法也基本上描述了HashMap在创建时候所做的事情,下边来详细看一下两个参数的构造方法的代码:
/**
*
* @param initialCapacity 初始化的table的容量
* @param loadFactor 负载因子
*/
public HashMap(int initialCapacity, float loadFactor) {
// 对initialCapacity和loadFactor的校验
// 初始化table的容量小于0 抛出异常
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
// 初始化table的容量大于最大的容量, 将设置的初始容量设置为最大的table容量
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
// 负载因子小于0或者不是Float类型的数字抛出异常
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
// 为哈希表设置传入的容量和负载因子
this.loadFactor = loadFactor;
// 当调用HashMap的构造方法创建对象的时候,在还没有往HashMap中放第一个元素之前(调用put方法),
// table对象还没有创建,threshold(扩容阈值)= capacity
// 当放进第一个元素的时候,此时会调用resize(扩容或者初始化table的大小)方法,此时会重新设置
// threshold = capacity * loadFactor
this.threshold = tableSizeFor(initialCapacity);
}
tableSizeFor方法做了什么事情呢,为什么要调用这个方法呢?其实是为了将传入的initialCapacity返回一个大于等于当前cap的数字,此数字一定是2的次方数。下边来研究一下这个方法是怎么回事。
/**
* Returns a power of two size for the given target capacity.
*
* 布尔运算 (用 1 代表 true,0 代表 false):
*
*
* 与:1 & 1 = 1, 1 & 0 = 0, 0 & 1 = 0, 0 & 0 = 0;
*
*
* 或:1 | 1 = 1, 1 | 0 = 1, 0 | 1 = 1, 0 | 0 = 0;
*
*
* 非:~0 = 1, ~1 = 0;
*
* 作用:返回一个大于等于当前cap的数字,此数字一定是2的次方数
* cap = 10
* n = 10-1 = 9
* n转换为二进制 -> 0b1001
* n >>> 1即n向右移一位 0b0100
* 0b1001 | 0b0100 >>> 0b1101
* 0b1101 | 0b0011 >>> 0b1111
* 0b1111 | 0b0000 >>> 0b1111
* ……
* 所以最后n = 0b1111,转换为十进制为15
* 通过 (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
* 计算之后返回16;
*/
static final int tableSizeFor(int cap) {
// 此处减去1是为了获取最接近传入数字的2的次方数,避免创建更大的数组,浪费内存资源。
// 比如传入的是8, 最后的返回值是16,而我们希望的是8(请各位自己计算)
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方法源码解析
在调用put方法的时候有两个关键的函数,hash()和putVal()
public V put(K key, V value) {
// hash(key) 计算哈希值
return putVal(hash(key), key, value, false, true);
}
hash方法并不是直接把key的hash值作为数组的hash值,而是考虑到了在哈希表中的为了避免频繁的哈希碰撞,让元素更均匀的分布在哈希表中所做的一次扰动,所以这个方法也称之为扰动函数。
此方法很简单
hash = (h = key.hashCode() ^ (h >>> 16));
为什么要进行h >>> 16的操作呢?
右位移16位,正好是32bit的一半,自己的高半区和低半区做异或,就是为了混合原始哈希码的高位和低位,以此来加大低位的随机性。而且混合后的低位掺杂了高位的部分特征,这样高位的信息也被变相保留下来
如果想深入了解,可以参考 HashMap之扰动函数和低位掩码.
下边就来看一下获取hash值的代码吧!
/**
*
* 作用:让key的hash值的高16位也参与路由运算
* 异或:相同返回0,不同返回1
* 假如key的hash为 0b1011 1101 0011 0110 1001 0001 1111 1110, 那么
*
* h 0b1011 1101 0011 0110 1001 0001 1111 1110
* ^
* h>>>16 0b0000 0000 0000 0000 1011 1101 0011 0110
* result 0b1011 1101 0011 0110 0110 0001 0010 1001
*
* 计算元素在table上的存储位置的算法是 (L-1) & hash,由于开始的时候table的长度比较小,
* 并且都是2的整次幂,那么L-1的二进制最后一定都是1,其余都是0
* 16-1=15。2进制表示是00000000 00000000 00001111。和某散列值做“与”操作如下
*
* 10111101 00110110 01100001 00101001
* &
* 00000000 00000000 00000000 00001111
* 00000000 00000000 00000000 00001001 //高位全部归零,只保留末四位
*
*
*/
static final int hash(Object key) {
int h;
// 扰动hash算法
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
下边就来看一下存储元素的核心代码putVal方法到底做了什么事情!代码中有详细的注释。
/**
* Implements Map.put and related methods.
*
* @param hash key的hash值
* @param key the key
* @param value the value to put
* @param onlyIfAbsent 如果为true,表示如果key相同,不覆盖value
* @param evict 如果为 false,则表处于创建模式
*/
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
// tab 引用当前hashmap的散列表
// p 表示当前散列表的元素
// n 表示当前数组的长度
// i 表示路由寻址的结果
Node<K,V>[] tab; Node<K,V> p; int n, i;
// 如果table(散列表)为空或者里边没有元素,对散列表进行初始化(调用resize方法)
// 在创建 HashMap 对象的时候并没有对table进行初始化,是为了避免创建HashMap之后,并不在里边放置元素,
// 导致内存的浪费,所以在第一次调用putVal进行初始化最消耗内存的散列表
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
// 最简单的情况,寻址找到的桶位(table的下标)正好是null,这个时候将key-value封装成Node对象,并放在i的位置
// (n - 1) & hash 计算元素的桶位
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);
// 桶位上已经有了相应的元素
else {
// e node临时元素,不为null的话,找到了一个与要插入的key-value一致的key的元素
// k 表示临时元素的key
Node<K,V> e; K k;
// 如果将要放置的元素的hash值和此桶位的元素一样,并且key的值相等,表示后续将要进行替换操作
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
// 此桶位的结构是树形结构
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
// 此桶位的结构是链表结构,并且链表的头元素和要插入的key不一致
else {
// 对链表进行循环,binCount表示此链表有多少元素
for (int binCount = 0; ; ++binCount) {
// 如果循环到下一个元素是null,表示此时的元素是最后一个元素,将临时元素放在尾端
if ((e = p.next) == null) {
// 将临时元素放在尾端
p.next = newNode(hash, key, value, null);
// 如果此链表的长度达到了转换为树形结构的条件,尝试转换为红黑树。下标-1为第一个元素
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
// 尝试转换为红黑树
treeifyBin(tab, hash);
break;
}
// 如果将要放置的元素的hash值和此桶位的元素一样,并且key的值相等,说明找到了相同key的node元素,需要进行替换操作
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
// 将临时元素赋值给p,此时的e是p的下一个元素(e = p.next)
p = e;
}
}
// e != null,表示此时的元素不是最后一个元素,即找到了一个相同key的node元素,需要进行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自增,如果自增后的值大于扩容阈值,则触发扩容
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
resize(扩容)方法源码解析
除了putVal方法还有一个很重要的方法,就是扩容方法resize。
resize方法也有很多设计巧妙的地方,很多地方值得我们去学习。下边来详细看一下其中的奥妙。
为了便于理解这个方法,在开始之前先说一下扩容前后的计算方法
假如扩容前的扩容大小 c1=16,那么扩容之后的 c2 = 16*2=32;
而计算在哈希表中桶位的函数是 i= (c-1)& hash
假如旧表下标为15的所有元素计算下标
即 16-1 & hash = 15
转换为二进制就是
1111
& hash值
res 1111
那么hash的后四位一定是1111,所以hash的后五位是11111或者01111。
扩容之后计算下标就是
1 1111
& 1 1111
res 1 1111 -> 31
或者
1 1111
& 0 1111
res 0 1111 -> 15
所以在旧表中的原始下标c1在扩容后的新表中的下标只能是(i为旧表中的下标位置)
c2 = i
或者
c2 = c1 + i
知道了以上的结论再来看一下resize方法:
/**
*
* 为什么需要扩容?
* 为了解决哈希冲突导致的链化影响查询效率的问题,扩容会缓解该问题
*
* @return the table
*/
final Node<K,V>[] resize() {
// oldTab 引用扩容前的哈希表
Node<K,V>[] oldTab = table;
// oldCap 扩容之前的table的数组长度
int oldCap = (oldTab == null) ? 0 : oldTab.length;
// oldThr 表示扩容前的扩容阈值,触发本次扩容的阈值
int oldThr = threshold;
// newCap 扩容之后的table的数组长度
// newThr 扩容之后的扩容阈值
int newCap, newThr = 0;
// 表示哈希表已经初始化过了,这是一次正常的扩容
if (oldCap > 0) {
// 扩容之前的数组大小已经达到了最大阈值后,则不扩容,且设置扩容条件为Integer.MAX_VALUE
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
// 如果oldCap左移一位实现数值翻倍,赋值给newCap,newCap小于最大的数组最大的长度,且扩容之前的数组长度小于16
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
// 新的扩容阈值翻倍
newThr = oldThr << 1; // double threshold
}
// oldCap == 0,说明散列表是null,还没有进行初始化
// 1. new HashMap(int initialCapacity, float loadFactor);
// 2. new HashMap(int initialCapacity);
// 3. new HashMap(Map<? extends K, ? extends V> m); 并且m有数据
else if (oldThr > 0) // initial capacity was placed in threshold
// 将扩容前的扩容阈值赋值给table的数组长度
newCap = oldThr;
// oldCap == 0,oldThr == 0
// new HashMap();
else { // zero initial threshold signifies using defaults
// 使用默认值
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
// newThr为0,通过newCap * loadFactor计算出newThr
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];
table = newTab;
// 说明哈希表本次扩容之前table不为null,已经进行过初始化
if (oldTab != null) {
// 对旧的哈希表进行循环
for (int j = 0; j < oldCap; ++j) {
// 当前node的节点
Node<K,V> e;
// 说明当前桶位上有数据,但是不确定是单个元素,还是链表,还是红黑树
if ((e = oldTab[j]) != null) {
// 将老数组此桶位上的数据置空,方便JVM GC时回收,节省内存
oldTab[j] = null;
// 如果当前node节点的下一个元素是空的,表示为单个元素
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变量
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;
}
可能对于最后的逻辑不是有点乱,我画了一张图便于理解,请大家图片结合代码理解一下:
结语
这边文章是基于JDK8的HashMap,等之后有时间我会出一篇JDK7 和JDK8的比较篇,还有HashMap一些其他方法的源码解读。
HashMap的源码中其实有很多设计非常巧妙的地方,非常值得大家学习这种编程的思想。我本人也从中学习到了很多精华,以后再工作中要学以致用。
HashMap家族还有很多的内容没有写出来,但是这篇文章对于理解HashMap的基本结构和逻辑应该没问题。文中有错误之处请各位大佬指正出来。