文章目录
一、HashMap简介
1.HashMap是什么
HashMap实际上是一种哈希表。哈希表,也称为散列表,是指将一组关键字通过散列(哈希)函数和解决冲突的方法映射到一个有限的连续的地址区间,这组关键字在区间的“像”作为记录在表中的存储位置,这个表叫做散列表,这个过程叫做散列,得到的地址叫做散列地址。
2.HashMap有什么特点
以key-value的形式存储数据,在不考虑哈希冲突的情况下,查找、删除、修改等操作的时间复杂度为O(1),可见性能之高。
允许key和value为null,但空值只能有一个。
元素是无序的,每次读取的顺序可能不一样。
HashMap的实现是异步的,迭代器是快速失败的。
3.HashMap有什么缺点
占有内存大,容量为30000的HashMap<int,int>占有的内存是同容量的int[]的20倍。
如果发生hash冲突频繁,会导致链表越来越长,极大影响性能。JDK1.8引入了红黑树,使得这种情况有所改善。
过度依赖hash算法。如果hash算法设计得不好,容易发生哈希冲突。
索引的计算(n - 1) & hash,跟容量和Hash值有关。如果发生扩容,则需要重新计算索引。所以,应预先估算好容量,避免扩容。
二、HashMap源码
1.HashMap结构
要想理解HashMap的诸多方法是如何实现以及为什么这么做的,就必须得知道HashMap的结构是怎么样。只有掌握了最根本的,才能深入理解其设计的思想。
查看HashMap的源码,发现HashMap存在着几个属性。
/* ---------------- Fields -------------- */
/**
* 表,在第一次使用时初始化,并根据需要调整大小。当分配大小时,表的长度总是2的整数次幂。
*/
transient Node<K,V>[] table;
/**
* 已添加键值对的Set集合,该集合的迭代器常用于遍历HashMap
*/
transient Set<Map.Entry<K,V>> entrySet;
/**
* 已添加键值对的数量
*/
transient int size;
/**
* 在结构上修改此HashMap的次数,例如新增、修改、删除。用于迭代器遍历数组时的快速失败机制
*/
transient int modCount;
/**
* HashMap的容量阈值
*/
int threshold;
/**
* 负载因子
*/
final float loadFactor;
由上面的table属性可以看出来,HashMap实际上是类型为Node<K,V>的数组。这时候又有一个疑问了,这个Node是一个什么东西呢?让我们接着看:
static class Node<K,V> implements Map.Entry<K,V> {
final int hash;
final K key;
V value;
Node<K,V> next;
Node(int hash, K key, V value, Node<K,V> next) {
this.hash = hash;
this.key = key;
this.value = value;
this.next = next;
}
public final K getKey() { return key; }
public final V getValue() { return value; }
public final String toString() { return key + "=" + value; }
public final int hashCode() {
return Objects.hashCode(key) ^ Objects.hashCode(value);
}
public final V setValue(V newValue) {
V oldValue = value;
value = newValue;
return oldValue;
}
public final boolean equals(Object o) {
if (o == this)
return true;
if (o instanceof Map.Entry) {
Map.Entry<?,?> e = (Map.Entry<?,?>)o;
if (Objects.equals(key, e.getKey()) &&
Objects.equals(value, e.getValue()))
return true;
}
return false;
}
}
Node具有指向另一个Node的属性,不难看出,它是一个单链表。
综上所述,HashMap的底层结构是以单链表为基本元素的数组。
2.HashMap的初始化
如果不传initialCapacity和loadFactor,则在HashMap初始化时默认容量大小为16,负载因子为0.75。
/**
* 构造器,initialCapacity为容量大小,loadFactor为负载因子
*/
public HashMap(int initialCapacity, float loadFactor) {
//如果容量小于零,则抛出异常
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " +
initialCapacity);
//如果容量大于最大值MAXIMUM_CAPACITY1<<<30,即2的30次方,则取最大值
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
//如果负载因子小于等于零或者非数字,则抛出异常(例如,new Float(0.0/0.0)
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " +
loadFactor);
this.loadFactor = loadFactor;
//通过tableSizeFor方法计算出容量大小
this.threshold = tableSizeFor(initialCapacity);
}
tableSizeFor方法:
/**
* |= 按位或赋值运算符,x |= y 等价于 x = x | y
* 算出大于等于输入参数且是2的整数次幂的最小值
*/
static final int tableSizeFor(int cap) {
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;
}
输入 0101(5) 1000(8) 001XXXXXXXXXXXXX
int n = cap - 1 0100 0111 001XXXXXXXXXXXXX
n |= n >>> 1; 0111 0111 n = 001XXXXXXXXXXXXX | 0001XXXXXXXXXXXX = 0011XXXXXXXXXXXX
n |= n >>> 2; 0111 0111 n = 0011XXXXXXXXXXXX | 000011XXXXXXXXXX = 001111XXXXXXXXXX
n |= n >>> 4; 0111 0111 n = 001111XXXXXXXXXX | 0000001111XXXXXX = 0011111111XXXXXX
n |= n >>> 8; 0111 0111 n = 0011111111XXXXXX | 0000000000111111 = 0011111111111111
n |= n >>> 16; 0111 0111 n = 0011111111111111 | 0000000000000000 = 0011111111111111
n + 1 1000(8) 1000(8) 0100000000000000
综上所述,这个算法是将最高位的1后面所有位都变成1,再将结果加一得到2的整数次幂。
这个时候就有另一个疑问了,int n = cap - 1这行代码的作用是什么?让我们把它去掉再试试。
选取非2的整数次幂但最低位为1,2的整数次幂,非2的整数次幂但最低位为0三个数字做分析:
输入 0101(5) 1000(8) 0110(6)
n |= n >>> 1; 0111 1111 0111
n |= n >>> 2; 0111 1111 0111
n |= n >>> 4; 0111 1111 0111
n |= n >>> 8; 0111 1111 0111
n |= n >>> 16; 0111 1111 0111
输出 1000(8) 10000(16) 1000(8)
综上所述,去掉int n = cap - 1后,对传参为2的整数次幂有影响。实际上只需要8的容量,但算出来是16,显然会占有更多的空间。
3.put方法
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
/**
*添加元素
*hash 哈希值,key 关键字
*onlyAbsent 是否覆盖,如果为false,则表示后添加的值会覆盖旧值
*evict参数用于LinkedHashMap中的尾部操作,这里没有实际意义。
*/
final V putVal(int hash, K key, V value, boolean onlyIfAbsent,
boolean evict) {
//临时表
Node<K,V>[] tab;
//临时结点
Node<K,V> p;
//n 表长度,i 索引
int n, i;
//如果当前表为空或者表的长度为0,则使用resize方法扩容,并将扩容的表长赋值到n(后面会说到resize方法)
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//计算索引值,并判断该位置上是否有元素
if ((p = tab[i = (n - 1) & hash]) == null)
/**
*如果没有,则创建一个首结点
*/
tab[i] = newNode(hash, key, value, null);
else {
/**
*如果有,则对比已存在的结点,找出链头,覆盖旧值
*/
Node<K,V> e; K k;
//如果旧结点的hash值等于传入的hash值,并且旧结点的key值等于传入的key值,则将旧结点复制到e结点。
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;
/**
*hash值相同,但key不同,发生哈希冲突
*/
//如果旧结点是红黑树的结点,则添加树结点。(JDK1.8中,如果链表长度大于8,则转化为红黑树)
else if (p instanceof TreeNode)
e = ((TreeNode<K,V>)p).putTreeVal(this, tab, hash, key, value);
else {
//这个循环意在找出当前链表的链头结点
for (int binCount = 0; ; ++binCount) {
//如果当前结点没有后继结点,即连头结点,那么在表头插入一个新结点
if ((e = p.next) == null) {
p.next = newNode(hash, key, value, null);
//如果链表的长度大于等于8,则转化为红黑树
if (binCount >= TREEIFY_THRESHOLD - 1) // -1 for 1st
treeifyBin(tab, hash);
break;
}
//如果当前结点的后继结点的key值和hash值与传入值都相等,则跳出当前循环,e为链头结点
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
//条件都不符合,则将e复制到p,继续对比下一个结点
p = e;
}
}
//如果e不为空,那么e的value值被传入的value值覆盖
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e);
return oldValue;
}
}
//hashMap修改次数加一
++modCount;
//如果存在的元素数量即将超过当前表的容量,则扩容
if (++size > threshold)
resize();
afterNodeInsertion(evict);
return null;
}
4.get方法
public V get(Object key) {
Node<K,V> e;
//如果getNode(hash(key), key)返回的对象不为空,则返回该对象的value值
return (e = getNode(hash(key), key)) == null ? null : e.value;
}
/**
* 获取元素
*/
final Node<K,V> getNode(int hash, Object key) {
Node<K,V>[] tab;
Node<K,V> first, e;
int n; K k;
//如果表不为空,长度大于零,且该索引上存在元素,则继续往下执行
if ((tab = table) != null && (n = tab.length) > 0 &&
(first = tab[(n - 1) & hash]) != null) {
//如果头结点的hash值和key值与传入的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) {
//如果该结点是红黑树结点,则调用getTreeNode方法获得结点。
if (first instanceof TreeNode)
return ((TreeNode<K,V>)first).getTreeNode(hash, key);
/**
* 遍历链表,找出hash值和key值与传入的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;
}
5.resize方法
/**
* Initializes or doubles table size. If null, allocates in
* accord with initial capacity target held in field threshold.
* Otherwise, because we are using power-of-two expansion, the
* elements from each bin must either stay at same index, or move
* with a power of two offset in the new table.
* 初始化或翻倍表容量。如果表为空,则根据默认的容量阈值初始化容器。
* 否则,由于容量值是2的整数次幂,数组元素的索引应与扩容前表对应元素的索引相同,或者偏移2的整数次幂。
*
* @return the table
*/
final Node<K,V>[] resize() {
//旧表数组
Node<K,V>[] oldTab = table;
//旧表容量
int oldCap = (oldTab == null) ? 0 : oldTab.length;
//旧表的容量阈值
int oldThr = threshold;
//newCap 扩容后的容量, newThr 扩容后的容量阈值
int newCap, newThr = 0;
//如果旧表容量大于零,继续执行
if (oldCap > 0) {
//如果旧表容量大于MAXIMUM_CAPACITY = 1 << 30,则取最大值
if (oldCap >= MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return oldTab;
}
//如果旧表的容量乘2小于最大值1 << 30,且大于等于默认值16,则将旧表的容量阈值乘2,并赋值给newThr
//值得注意的是,此时newCap应该等于oldCap乘2
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // double threshold
}
else if (oldThr > 0)
/**
* 如果表容量为零,但容量阈值大于零,即表调用有参构造函数初始化后但未使用
* 调用public HashMap(int initialCapacity, float loadFactor)或者public HashMap(int initialCapacity)都会执行
* this.threshold = tableSizeFor(initialCapacity),使得表的阈值threshold为2的整数次幂,并赋值给newCap,作为初始化容量
*/
newCap = oldThr;
else {
/**
* 如果表容量为零,容量阈值为零,即表调用无参构造函数初始化后但未使用
* 调用public HashMap()只会执行this.loadFactor = DEFAULT_LOAD_FACTOR,不会初始化容量和容量阈值
* 扩容后的容量newCap为DEFAULT_INITIAL_CAPACITY=16
* 扩容后的容量阈值newThr为DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY = 16 * 0.75 = 12。如果阈值不为整数,则向下舍入取整。
*/
newCap = DEFAULT_INITIAL_CAPACITY;
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);
}
//扩容后的容量阈值为零时
if (newThr == 0) {
//ft为扩容后的容量乘以默认负载因子0.75
float ft = (float)newCap * loadFactor;
/**
* 如果扩容后的容量小于容量最大值1 << 30并且ft小于容量最大值,则将ft取整(向下舍入),并赋值到扩容后的容量阈值newThr;
* 否则,扩容后的容量阈值取integer的最大值0x7fffffff(符号位为0,其余都是1)
*/
newThr = (newCap < MAXIMUM_CAPACITY && ft < (float)MAXIMUM_CAPACITY ?
(int)ft : Integer.MAX_VALUE);
}
//将扩容后的容量阈值
threshold = newThr;
//屏蔽警告
@SuppressWarnings({"rawtypes","unchecked"})
//初始化一个新容量的Node数组并赋值给table
Node<K,V>[] newTab = (Node<K,V>[])new Node[newCap];
table = newTab;
//如果旧表不为空
if (oldTab != null) {
//遍历旧表的结点数组
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
//如果当前结点不为空,则赋值给临时变量e
if ((e = oldTab[j]) != null) {
//置空,便于垃圾回收机制清理,释放内存
oldTab[j] = null;
//如果当前结点没有后继结点,即唯一的结点,那么把e放入新的结点数组
if (e.next == null)
newTab[e.hash & (newCap - 1)] = e;
/**
* 如果当前结点是红黑树结点,则调用split方法重新映射红黑树
* 如果元素个数小于红黑树转链表元素个数阈值(默认是6),则退化为链表;
*/
else if (e instanceof TreeNode)
((TreeNode<K,V>)e).split(this, newTab, j, oldCap);
else {
//寻找数组中每个链表的链头结点,并复制到新数组相应索引下
Node<K,V> loHead = null, loTail = null;
Node<K,V> hiHead = null, hiTail = null;
Node<K,V> next;
do {
next = e.next;
/**
* e.hash&oldCap这个算法是JDK1.8才有的,JDK1.7用的是e.hash & oldCap-1。
* 相对于JDK1.7的算法,新算法把之前的冲突的结点均匀地分散到新的bucket了
* 此外,还省去了重新计算Hash值的时间消耗。
*、
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.什么时候需要重写hashCode方法?重写hashCode方法一定需要重写equals方法吗?
当HashMap传入的key为对象时,需要重写hashCode方法。如果不重写hashCode方法,则是根据该对象的内存地址算出hash值,这会导致即使是相同属性值的两个对象,算出来的hash值还是不同的。在进行put操作时,会判定这两个KEY为不等,进行多余的put操作,占用额外的空间。
如果只是重写了hashCode方法,虽然可以保证相同属性值的两个对象的hash值相等,但是equals方法仍然比较的是两个对象的内存地址。因为在get和put方法中用到了很多的equals,重写hashCode但不重写equals,也是会出现问题的。
2.为什么HashMap迭代器是快速失败的?如何实现的?
可以查看笔者的另一篇博文(https://blog.csdn.net/weixin_33656548/article/details/85064325)
3.为什么HashMap的容量大小都是2的整数次幂?
这取决于HashMap构造器中的这一段代码this.threshold = tableSizeFor(initialCapacity),cap指的是初始化时传入的容量参数。tableSizeFor方法会返回大于等于输入参数且是2的整数次幂的最小值。例如,传参为5,则会返回8作为初始容量。
4.为什么HashMap计算索引的算法是(n - 1) & hash?
可以查看下面这一篇博文,解释得很通透(https://www.cnblogs.com/ysocean/p/9054804.html)