HashMap 学习(摘抄)
原文查看:
- Java数据结构和算法(十三)——哈希表 : https://www.cnblogs.com/ysocean/p/8032656.html
- JDK1.8源码(七)——java.util.HashMap 类 : https://www.cnblogs.com/ysocean/p/8711071.html#_label0
- Java8的HashMap详解 : https://blog.csdn.net/login_sonata/article/details/76598675
- HashMap源码中的tableSizeFor(int cap)方法 : https://www.jianshu.com/p/4ed9260d988c
- 位运算有符号右移和无符号右移 : https://www.cnblogs.com/345214483-qq/p/6472136.html
HashMap是基于哈希表的Map接口的实现,允许使用null值和null键。HashMap是非线程安全的,也就是说在多个线程同时对HashMap中的某个元素进行增删改操作的时候,是不能保证数据的一致性的。
如果需要满足线程安全,可以用 Collections的synchronizedMap方法使HashMap具有线程安全的能力,或者使用ConcurrentHashMap。
遇到冲突时,HashMap 是采用的链地址法来解决,在 JDK1.7 中,HashMap 是由 数组+链表构成的。但是在 JDK1.8 中,HashMap 是由 数组+链表+红黑树构成,新增了红黑树作为底层数据结构,结构变得复杂了,但是效率也变的更高效。
HashMap 类
- 首先该类实现了一个 Map 接口,该接口定义了一组键值对映射通用的操作。
- JDK 还为我们提供了一个抽象类 AbstractMap ,该抽象类继承 Map 接口,所以如果我们不想实现所有的 Map 接口方法,就可以选择继承抽象类 AbstractMap 。
- HashMap 集合还实现了 Cloneable 接口以及 Serializable 接口,分别用来进行对象克隆以及将对象进行序列化。
public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable
HashMap 内部类
Node 类
Node是HashMap的一个内部类,实现了Map.Entry接口,本质就是一个映射(键值对)。
/**
* Basic hash bin node, used for most entries. (See below for
* TreeNode subclass, and in LinkedHashMap for its Entry subclass.)
*/
static class Node<K,V> implements Map.Entry<K,V> {
final int hash; // 用来定位数组索引位置
final K key;
V value;
Node<K,V> next; //链表的下一个node
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() { ...}
public final V setValue(V newValue) { ... }
public final boolean equals(Object o) { ... }
}
HashMap 字段属性
常量
//序列化和反序列化时,通过该字段进行版本一致性验证
private static final long serialVersionUID = 362498820763181265L;
//默认 HashMap 集合初始容量为16(必须是 2 的倍数)
static final int DEFAULT_INITIAL_CAPACITY = 1 << 4; // aka 16
//集合的最大容量,如果通过带参构造指定的最大容量超过此数,默认还是使用此数
static final int MAXIMUM_CAPACITY = 1 << 30;
//默认的填充因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;
//当桶(bucket)上的结点数大于这个值时会转成红黑树(JDK1.8新增)
static final int TREEIFY_THRESHOLD = 8;
//当桶(bucket)上的节点数小于这个值时会转成链表(JDK1.8新增)
static final int UNTREEIFY_THRESHOLD = 6;
/**(JDK1.8新增)
* 当集合中的容量大于这个值时,表中的桶才能进行树形化 ,否则桶内元素太多时会扩容,
* 而不是树形化 为了避免进行扩容、树形化选择的冲突,这个值不能小于 4 * TREEIFY_THRESHOLD
*/
static final int MIN_TREEIFY_CAPACITY = 64;
变量
// 初始化使用,长度总是 2的幂 哈希桶数组
transient Node<K,V>[] table;
// 保存缓存的entrySet()
transient Set<Map.Entry<K,V>> entrySet;
// 此映射中包含的键值映射的数量。(集合存储键值对的数量)
transient int size;
// 记录集合被修改的次数,主要用于迭代器中的快速失败 (? 没理解) 出现线程问题时,负责及时抛异常
transient int modCount;
// 调整大小的下一个大小值(容量*加载因子)。 capacity * loadFactor
int threshold;
// 散列表的加载因子。
final float loadFactor;
- Node<K,V>[] table
HashMap 是由数组+链表+红黑树组成,这里的数组就是 table 字段。哈希桶数组。 - size
集合中存放key-value 的实时对数。 - loadFactor
装载因子,是用来衡量 HashMap 满的程度,计算HashMap的实时装载因子的方法为:size/capacity,而不是占用桶的数量去除以capacity。capacity 是桶的数量,也就是 table 的长度length。
默认的负载因子0.75 是对空间和时间效率的一个平衡选择。- 加载因子越大,填满的元素越多,好处是: 空间利用率高了,但: 冲突的机会加大了.链表长度会越来越长,查找效率降低。如果内存空间紧张而对时间效率要求不高,可以增加负载因子 loadFactor 的值,这个值可以大于1。
- 加载因子越小,填满的元素越少,好处是: 冲突的机会减小,但: 空间浪费多了. 表中的数据将过于稀疏(很多空间还没用,就开始扩容了)。如果内存空间很多而又对时间效率要求很高,可以降低负载因子loadFactor 的值
- modCount
modCount字段主要用来记录HashMap内部结构发生变化的次数。内部结构发生变化指的是结构发生变化,例如put新键值对,但是某个key对应的value值被覆盖不属于结构变化。 - threshold
计算公式:capacity * loadFactor。这个值是当前已占用数组长度的最大值。过这个数目就重新resize(扩容),扩容后的 HashMap 容量是之前容量的两倍。
HashMap 构造函数
无参构造函数
// 默认构造函数,初始化加载因子loadFactor = 0.75
public HashMap() {
this.loadFactor = DEFAULT_LOAD_FACTOR; // all other fields defaulted
}
有参构造函数
public HashMap(int initialCapacity) {
this(initialCapacity, DEFAULT_LOAD_FACTOR);
}
/**
* @param initialCapacity 指定初始化容量
* @param loadFactor 加载因子 0.75
* @throws IllegalArgumentException if the initial capacity is negative
* or the load factor is nonpositive
*/
public HashMap(int initialCapacity, float loadFactor) {
//初始化容量不能小于 0 ,否则抛出异常
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity);
//如果初始化容量大于2的30次方,则初始化容量都为2的30次方
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
//如果加载因子小于0,或者加载因子是一个非数值,抛出异常
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " + loadFactor);
this.loadFactor = loadFactor;
this.threshold = tableSizeFor(initialCapacity);
}
- tableSizeFor(int cap) 方法
主要功能是返回一个比给定整数大且最接近的2的幂次方整数,如给定7,返回2的3次方8。
/**
* Returns a power of two size for the given target capacity.
*/
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;
}
>>>
: 无符号右移 (无论是正数还是负数,高位通通补0。)>>
: 有符号右移 (正数右移高位补0,负数右移高位补1。)
n |= n >>> 1 分解为:
n1 = n >>> 1
n = n | n1
假定cap也就是给定数的二进制形式为 00..01XXXXXXX
,(X代表可为0也可为1,X前面的1为从最高位开始第一个为1的那一位)
第一步: n |= n >>> 1
n
的二进制:00..01XXXXXXX
n >>> 1
(向右移动一位,即n的原值除以2以后,获得的2进制): 00..001XXXXXX
n
与 n >>> 1
做 |(位或运算符)或得到新 n: 00..011XXXXXX
第二步: n |= n >>> 2
n
的二进制: 00..011XXXXXX
n >>> 2
: 00..00011XXXX
n
与 n >>> 2
做 |(位或运算符)或得到新 n:: 00..01111XXXX
这个算法不断的通过把第一个1开始后面的位变成1,本例由00..01XXXXXXX
=> 00..011111111
,最后再返回n+1;
直观体验一下,打印流程:
public class Test {
private static final int MAXIMUM_CAPACITY = 1 << 30;
public static void main(String[] args) {
System.out.println(MAXIMUM_CAPACITY);
System.out.println( "返回值n: " + tableSizeFor(1256));
}
static final int tableSizeFor(int cap) {
int n = cap - 1;
System.out.println("=n=");
System.out.println(Integer.toBinaryString(n));
System.out.println(n);
n |= n >>> 1;
System.out.println("=n |= n >>> 1=");
System.out.println(Integer.toBinaryString(n));
System.out.println(n);
n |= n >>> 2;
System.out.println("=n |= n >>> 2=");
System.out.println(Integer.toBinaryString(n));
System.out.println(n);
n |= n >>> 4;
System.out.println("=n |= n >>> 4=");
System.out.println(Integer.toBinaryString(n));
System.out.println(n);
n |= n >>> 8;
System.out.println("=n |= n >>> 8=");
System.out.println(Integer.toBinaryString(n));
System.out.println(n);
n |= n >>> 16;
System.out.println("=n |= n >>> 16=");
System.out.println(Integer.toBinaryString(n));
System.out.println(n);
return (n < 0) ? 1 : (n >= MAXIMUM_CAPACITY) ? MAXIMUM_CAPACITY : n + 1;
}
}
HashMap 方法
hash() 确定哈希桶数组索引位置
static final int hash(Object key) {
int h;
return (key == null) ? 0 : (h = key.hashCode()) ^ (h >>> 16);
}
i = (table.length - 1) & hash;//这一步是在后面添加元素putVal()方法中进行位置的确定
主要分为三步:
1、取 hashCode 值: key.hashCode()
- 这里点进去 Object 的
public native int hashCode();
方法,调用本地方法。 - 这里获取 hashCode() 方法的值是变量,但是我们知道,对于任意给定的对象,只要它的 hashCode() 返回值相同,那么程序调用 hash(Object key) 所计算得到的 hash码 值总是相同的。
2、高位参与运算:h>>>16
3、取模运算:(n-1) & hash
HashMap 使用的方法很巧妙,它通过 hash & (table.length -1)来得到该对象的保存位,前面说过 HashMap 底层数组的长度总是2的n次方,这是HashMap在速度上的优化。当 length 总是2的n次方时,hash & (length-1)运算等价于对 length 取模,也就是 hash%length,但是&比%具有更高的效率。 比如 n % 32 = n & (32 -1)
这也解释了为什么要保证数组的长度总是2的n次方。
再就是在 JDK1.8 中还有个高位参与运算,hashCode() 得到的是一个32位 int 类型的值,通过hashCode()的高16位 异或 低16位实现的:(h = k.hashCode()) ^ (h >>> 16),主要是从速度、功效、质量来考虑的,这么做可以在数组table的length比较小的时候,也能保证考虑到高低Bit都参与到Hash的计算中,同时不会有太大的开销。
put() 添加元素
//hash(key)就是上面讲的hash方法,对其进行了第一步和第二步处理
public V put(K key, V value) {
return putVal(hash(key), key, value, false, true);
}
/**
*
* @param hash 索引的位置
* @param key 键
* @param value 值
* @param onlyIfAbsent true 表示不要更改现有值
* @param evict false表示table处于创建模式
* @return
*/
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为null或者长度为0,则进行初始化
//resize()方法本来是用于扩容,由于初始化没有实际分配空间,这里用该方法进行空间分配,后面会详细讲解该方法
if ((tab = table) == null || (n = tab.length) == 0)
n = (tab = resize()).length;
//注意:这里用到了前面讲解获得key的hash码的第三步,取模运算,下面的if-else分别是 tab[i] 为null和不为null
if ((p = tab[i = (n - 1) & hash]) == null)
tab[i] = newNode(hash, key, value, null);//tab[i] 为null,直接将新的key-value插入到计算的索引i位置
else {//tab[i] 不为null,表示该位置已经有值了
Node<K,V> e; K k;
if (p.hash == hash &&
((k = p.key) == key || (key != null && key.equals(k))))
e = p;//节点key已经有值了,直接用新值覆盖
//该链是红黑树
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已经存在直接覆盖value
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
break;
p = e;
}
}
if (e != null) { // existing mapping for key
V oldValue = e.value;
if (!onlyIfAbsent || oldValue == null)
e.value = value;
afterNodeAccess(e); // 空的方法实现LinkedHashMap 会用到,LinkedHashMap 是继承的 HashMap,并且重写了该方法
return oldValue;
}
}
++modCount;//用作修改和新增快速失败
if (++size > threshold)//超过最大容量,进行扩容
resize();
afterNodeInsertion(evict); // 空的方法实现LinkedHashMap 会用到,LinkedHashMap 是继承的 HashMap,并且重写了该方法
return null;
}
if (++size > threshold)//超过最大容量,进行扩容
resize();
afterNodeInsertion(evict);
return null;
}
只要是调用 put() 方法添加元素,那么就会调用 ++size (这里有个例外是插入重复 key 的键值对,不会调用,重复key元素不会影响size)
HashMap 是由数组+链表+红黑树(JDK1.8)组成,如果在添加元素时,发生冲突,会将冲突的数放在链表上,当链表长度超过8时,会自动转换成红黑树。
resize() 扩容
final Node<K,V>[] resize() {
Node<K,V>[] oldTab = table;
int oldCap = (oldTab == null) ? 0 : oldTab.length;//原数组如果为null,则长度赋值0
int oldThr = threshold;
int newCap, newThr = 0;
if (oldCap > 0) {//如果原数组长度大于0
if (oldCap >= MAXIMUM_CAPACITY) {//数组大小如果已经大于等于最大值(2^30)
threshold = Integer.MAX_VALUE;//修改阈值为int的最大值(2^31-1),这样以后就不会扩容了
return oldTab;
}
//原数组长度大于等于初始化长度16,并且原数组长度扩大1倍也小于2^30次方
else if ((newCap = oldCap << 1) < MAXIMUM_CAPACITY &&
oldCap >= DEFAULT_INITIAL_CAPACITY)
newThr = oldThr << 1; // 阀值扩大1倍
}
else if (oldThr > 0) //旧阀值大于0,则将新容量直接等于就阀值
newCap = oldThr;
else {//阀值等于0,oldCap也等于0(集合未进行初始化)
newCap = DEFAULT_INITIAL_CAPACITY;//数组长度初始化为16
newThr = (int)(DEFAULT_LOAD_FACTOR * DEFAULT_INITIAL_CAPACITY);//阀值等于16*0.75=12
}
//计算新的阀值上限
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;
if (oldTab != null) {
//把每个bucket都移动到新的buckets中
for (int j = 0; j < oldCap; ++j) {
Node<K,V> e;
if ((e = oldTab[j]) != null) {
oldTab[j] = null;//元数据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;
}
//原索引+oldCap
else {
if (hiTail == null)
hiHead = e;
else
hiTail.next = e;
hiTail = e;
}
} while ((e = next) != null);
//原索引放到bucket里
if (loTail != null) {
loTail.next = null;
newTab[j] = loHead;
}
//原索引+oldCap放到bucket里
if (hiTail != null) {
hiTail.next = null;
newTab[j + oldCap] = hiHead;
}
}
}
}
}
return newTab;
}
n为table的长度,图(a)表示扩容前的key1和key2两种key确定索引位置的示例,图(b)表示扩容后key1和key2两种key确定索引位置的示例,其中hash1是key1对应的哈希与高位运算结果。
元素在重新计算hash之后,因为n变为2倍,那么n-1的mask范围在高位多1bit(红色),因此新的index就会发生这样的变化:
可以看看下图为16扩充为32的resize示意图:
JDK1.8使用的是2次幂的扩展(指长度扩为原来2倍),所以,元素的位置要么是在原位置,要么是在原位置再移动2次幂的位置。
我们在扩充HashMap的时候,不需要像JDK1.7的实现那样重新计算hash,只需要看看原来的hash值新增的那个bit是1还是0就好了,是0的话索引没变,是1的话索引变成“原索引+oldCap(原数组的长度)”。