文章内容如有错误或论述不完善的地方,欢迎大家指点,让我们共同进步。 &( ^_^ )
1、HashMap介绍
HashMap 是一个存储key-value的容器,它使用数组+链表(1.8链表根据存储个数会转变为红黑树)的方式来存储数据,这种方式也是为了避免hash指针碰撞。
HashMap 的实现不是同步的,这意味着它不是线程安全的。它的key、value都可以为null。此外,HashMap中的映射不是有序的。
他有两个参数影响其性能:初始容量和加载因子。默认初始容量是16,加载因子是0.75。容量是哈希表中桶(Entry数组)的数量,初始容量只是哈希表在创建时的容量。加载因子是哈希表在其容量自动增加之前可以达到多满的一种尺度。当哈希表中的条目数超出了加载因子与当前容量的乘积时,通过调用 resize 方法将容量翻倍。
2、API介绍
2.1 继承关系
HashMap 继承 抽象类AbstractMap ,实现Map、Cloneable(克隆)、Serializable(序列化)接口;
2.2 构造函数
方法 | 描述 |
---|---|
HashMap() | 构造一个具有默认初始容量 (16) 和默认加载因子 (0.75) 的空 HashMap。 |
HashMap(int initialCapacity) | 构造一个带指定初始容量和默认加载因子 (0.75) 的空 HashMap |
HashMap(int initialCapacity, float loadFactor) | 构造一个带指定初始容量和加载因子的空 HashMap。 |
HashMap(Map m) | 构造一个映射关系与指定 Map 相同的新 HashMap |
2.3 属性
// 默认的初始容量是16,必须是2的幂。
static final int DEFAULT_INITIAL_CAPACITY = 16;
// 最大容量(必须是2的幂且小于2的30次方,传入容量过大将被这个值替换)
static final int MAXIMUM_CAPACITY = 1 << 30;
// 默认加载因子
static final float DEFAULT_LOAD_FACTOR = 0.75f;
// 存储数据的Entry数组,长度是2的幂。
// HashMap是采用拉链法实现的,每一个Entry本质上是一个单向链表
transient Entry<K,V>[] table;
// HashMap的大小,它是HashMap保存的键值对的数量
transient int size;
// HashMap的阈值,用于判断是否需要调整HashMap的容量(threshold = 容量*加载因子)
int threshold;
// 加载因子实际大小
final float loadFactor;
// HashMap结构修改的次数【结构-改变映射数量】
transient volatile int modCount;
//此映射中包含的键 - 值映射的数量。
transient int size;
//表示是否要对字符串键的HashMap使用备选哈希函数。
transient boolean useAltHashing;
2.4 方法
略
3、hashcode 和 hash算法
3.1 位运算相关知识
在Java中,所有数据的表示方式都是以补码形式来表示,可以解决0存储的问题,可以把减法视为加法运算。
正数:原码、反码、补码相同
负数:正数原码–符号位变为1,反码–除符号位外其余位取反,补码–反码加1
位运算
按位与 &:两个补码的数一一对应,对应位置的数都为1,结果为1,否则为0;
按位或 |:两个补码的数一一对应,对应位置的数至少一位为1,结果为1,否则为0;
按位异或 ^:两个补码的数一一对应,对应位置的数一个为1、一个为0,结果为1,否则为0;
按位取反 ~:补码中0变成1、1变成0;
左移运算符<< : 将参数的补码向左边移动指定的位数,低位补0;
- 左移相当于乘法,符号位是不移动的,快速计算:参数*2^位移个数
“有符号”右移运算符>>:将参数的补码向右边移动指定的位数。当值为正时,在高位补0,值为负,则在高位补1.
- 快速计算-正数: 参数 / 2 ^位移个数,如8<<1 = 8/2^1=4、8<<3 = 8/2^3=1,有负数舍弃掉;
- 快速计算-负数: 参数 * 2 ^位移个数,如-9<<3 = -9*2^3=2、-23<<3 = -23*2^3=31,有余数就进一位(无论余数是多少)
- 无符号”右移运算 符 >>>: 将参数的补码向右边移动指定的位数,忽略符号位,空位以0补齐。
- 快速计算-正数: 同 >> 的正数运行;
- 快速计算-负数:规律待找寻
3.2 计算int值的32位补码
/**
* 计算给定的int值的32位补码
* @param numerical 整数数值
*/
public static void intCoding(int numerical){
System.out.print(numerical+"的补码是:");
for(int i=0;i<32;i++){
int t = (numerical & 0x80000000 >>>i)>>>(31-i);
System.out.print(t);
}
}
3.2 hashcode算法
put方法中有以下两个方法:
int hash = hash(key); //获取key的hashCode
int i = indexFor(hash, table.length); //对key的hashCode取模计算数组下标
hash方法内部使用了大量的位移和异或操作:
主要用途是打散key.hashCode()返回值中1所在的位置,也就是让返回值补码中的1分散的均匀些;原因是取模利用“按位与”来实现,因此当key.hashCode中1都分布在高位0分布在低位,而另一个值的分布相反时,那结果会相当美丽(结果都是0),简单的说就是避免取模后大量出现0。
indexFor方法求的是数组下标(hashMap结构是:数组+链表),该方法需要尽量保障数据的分散,因此选择“取模”来计算下标。但在java中取模和除法是消耗较大的操作,而“按位与”相对来说消耗要少很多。
static int indexFor(int h, int length) {
return h & (length-1); //length是当前容量
}
为什么让key的hash值 与 hashMap的容量-1做 按位与操作?
在源码中length是当前容量,按规则容量用于是一个偶数,让一个偶数 与 h按位与,得到的都是偶数下标,会浪费近一半的空间,而奇数就不会。具体原因是 偶数的补码最后一位是0,因此不管h的最后一位是什么,结果都为0,所以(length-1)为奇数可以保证结果的最后一位是1,这样与h按位与,最后一位的结果可能是1也可能是0(因为h的最后一份是1or0)。
4、源码解析
4.1 模型
hashMap的一个数组+链表的模型结构,在源码中结构如下:
和key映射的数组
transient Entry<K,V>[] table;
链表中的数据节点
static class Entry<K,V> implements Map.Entry<K,V> {
final K key; //key值
V value; //value值
Entry<K,V> next; //下一个节点
int hash; //key的hash值
//创建一个新的Entry
//输入参数包括"哈希值(h)", "键(k)", "值(v)", "下一节点(n)"
Entry(int h, K k, V v, Entry<K,V> n)
public final K getKey()
public final V getValue()
//更新value的值,返回旧值
public final V setValue(V newValue)
//判断两个Entry是否相等
//若两个Entry的“key”和“value”都相等,则返回true,否则,返回false
public final boolean equals(Object o)
//key和value按位异或,重写hashCode()
public final int hashCode()
public final String toString()
//当向HashMap中添加元素时,绘调用recordAccess(),这里不做任何处理
void recordAccess(HashMap<K,V> m)
//当从HashMap中删除元素时,绘调用recordRemoval(),这里不做任何处理
void recordRemoval(HashMap<K,V> m)
}
从代码中,可以看出 Entry 实际上就是一个单向链表。这也是为什么我们说HashMap是通过拉链法解决哈希冲突的。
Entry 实现了Map.Entry 接口,即实现getKey(), getValue(), setValue(V value), equals(Object o), hashCode()这些函数。这些都是基本的读取/修改key、value值的函数。
4.2 hashMap的构造函数
hashMap共有4个构造函数,但最终调用的都是一个构造函数
/**
* @param initialCapacity 容量大小
* @param loadFactor 加载因子
*/
public HashMap(int initialCapacity, float loadFactor) {
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity);
// HashMap的最大容量只能是MAXIMUM_CAPACITY
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
if (loadFactor <= 0 || Float.isNaN(loadFactor))
throw new IllegalArgumentException("Illegal load factor: " + loadFactor);
// 保证容器大小是2的幂
int capacity = 1;
while (capacity < initialCapacity)
capacity <<= 1;
// 设置“加载因子”
this.loadFactor = loadFactor;
// 设置“HashMap阈值”,当HashMap中存储数据的数量达到threshold时,就需要将HashMap的容量加倍。
threshold = (int)Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
// 创建Entry数组,用来保存数据
table = new Entry[capacity];
//计算是否对字符串键的HashMap使用备选哈希函数
useAltHashing = sun.misc.VM.isBooted() &&
(capacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);
//在hashMap里是空方法,需要子类去实现
init();
}
4.3 put 方法
public V put(K key, V value) {
if (key == null)
return putForNullKey(value);
//求key的hash值
int hash = hash(key);
//对key的hash值 和 容器长度-1 取模求得下标(table的下标)==尽量打散下标的分布
int i = indexFor(hash, table.length);
//key值hash后的下标索引对应值非null,进行遍历
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
// hash值相等 并且 key值相等,执行更新操作,并返回旧值结束程序
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
//更新 ashMap结构修改的次数【结构-改变映射数量】
modCount++;
//链表最前面插入一个新的值
addEntry(hash, key, value, i);
return null;
}
容量的扩容在putAll方法里有扩容逻辑;
4.4 get方法
public V get(Object key) {
if (key == null)
return getForNullKey();
//根据key获取对应的Entry
Entry<K,V> entry = getEntry(key);
//null返回null,非null返回value
return null == entry ? null : entry.getValue();
}
//根据key获取对应的Entry
final Entry<K,V> getEntry(Object key) {
//获取key的hash值
int hash = (key == null) ? 0 : hash(key);
//取模获取key的下标,从table表中得到链表
for (Entry<K,V> e = table[indexFor(hash, table.length)];
e != null;
e = e.next) {
Object k;
// hash值相同 并且 key相同,说明找到对应的节点,返回
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
}
//没有找到返回空
return null;
}
4.5 remove 方法
public V remove(Object key) {
//移除指定key对应的Entry
Entry<K,V> e = removeEntryForKey(key);
return (e == null ? null : e.value);
}
final Entry<K,V> removeEntryForKey(Object key) {
//获取key的hash值
int hash = (key == null) ? 0 : hash(key);
//获取key对应的下标
int i = indexFor(hash, table.length);
//初始化等于链表的表头,也代表上一个节点
Entry<K,V> prev = table[i];
//初始化等于链表的表头,代表当前节点
Entry<K,V> e = prev;
while (e != null) {
//当前节点的下一个节点
Entry<K,V> next = e.next;
Object k;
//当前节点的hash和给定key的哈市相等 并且 key值相等,说明找到要删除的数据
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k)))) {
//HashMap结构修改的次数加1【结构-改变映射数量】
modCount++;
//键值映射数量减1
size--;
if (prev == e) //第一次循环
table[i] = next; //链表从next开始
else
prev.next = next; //跳过当前节点
//空操作
e.recordRemoval(this);
//返回删除的数值
return e;
}
prev = e;
e = next;
}
//这里返回的永远是null
return e;
}
4.5 putAll 方法
public void putAll(Map<? extends K, ? extends V> m) {
int numKeysToBeAdded = m.size();
if (numKeysToBeAdded == 0)
return;
/*
* 给定map的实际容量 大于 当前Map的阈值在进行扩容,
* 为什么不是(numKeysToBeAdded+table.length)>threshold的时候在去扩容,因为
* 考虑给定的map和原map里的key有相同的可能,避免扩容过大浪费空间
*/
if (numKeysToBeAdded > threshold) {
// targetCapacity = 给定map当下的最大容量
int targetCapacity = (int)(numKeysToBeAdded / loadFactor + 1);
// 给定map当下的最大容量 不能超过 程序规定的Map最大容量
if (targetCapacity > MAXIMUM_CAPACITY)
targetCapacity = MAXIMUM_CAPACITY;
//当前map的容量
int newCapacity = table.length;
//当前map的容量值 小于 给定map当下的最大容量,通过左移改变当前map的容量,每次扩大两倍
while (newCapacity < targetCapacity)
newCapacity <<= 1;
//扩容后的当前map的容量值 大于 当前map的容量,进行实质的扩容
if (newCapacity > table.length)
resize(newCapacity);
}
//通过put的方法把给定map里的值一个一个的添加到当前map里
for (Map.Entry<? extends K, ? extends V> e : m.entrySet())
put(e.getKey(), e.getValue());
}
4.6 resize 方法 进行扩容
//newCapacity 给定的新表的容量
void resize(int newCapacity) {
//新建一个变量,命名为旧表 并 指向当前的表
Entry[] oldTable = table;
//获取旧表的容量
int oldCapacity = oldTable.length;
//旧表的容量 等于 程序规定的Map最大容量(只能等于不可能超过)
if (oldCapacity == MAXIMUM_CAPACITY) {
// 当前map的阈值 等于 int的最大值,并返回,也就是不扩容了
threshold = Integer.MAX_VALUE;
return;
}
//初始化一个新表,容量给定的容量(进行过扩容后的容量)
Entry[] newTable = new Entry[newCapacity];
//计算是否需要对键重新进行哈希码的计算
boolean oldAltHashing = useAltHashing;
useAltHashing |= sun.misc.VM.isBooted() &&
(newCapacity >= Holder.ALTERNATIVE_HASHING_THRESHOLD);
boolean rehash = oldAltHashing ^ useAltHashing;
//旧表中的值一个一个的都放入到新表中(数组迁移);
//新表的容量改变了,重新计算后获取到的下标也发生了改变
transfer(newTable, rehash);
//新表 替换 当前map的表
table = newTable;
//重新进行HashMap的阈值
threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
}
putAll方法调用resize,调用方式请看【4.5 putAll 方法】的分析;
put方法也会调用resize,在put方法里新的容量计算方式很简单:2 * table.length;