整体介绍
image.png
HashMap 是一个采用哈希表实现的键值对集合，继承自AbstractMap，实现了 Map 接口。
-
操作时间
- HashMap的基本操作（
get put）只需要常量时间和少量的对比操作。时间复杂度为O(n)。 - HashMap迭代操作耗费时间与 HashMap的桶和HashMap内的键值对数量成正比
- HashMap的基本操作（
HashMap本身并不是线程同步的，使用了fail-fast机制，但不可靠。
想要同步可以用Map m = Collections.synchronizedMap(new HashMap(...))-
HashMap内的元素数量一旦达到某个阈值，就会触发桶扩充，扩大HashMap桶的数量，减小哈希冲突
- 阈值过大，HashMap内的哈希冲突严重，查找效率低
- 阈值过小，HashMap的rehashed（桶扩充）频繁，性能下降
-
放入HashMap的元素需要覆盖
hashCode()和equals()方法。-
hashCode()决定了对象会放在哪个桶里 -
equals()决定了在桶的链表中如何找到对应的对象
-
-
HashMap采用的是冲突链表方式解决哈希冲突问题
image.png
源码分析
键值对结构
HashMap的键值对的结构和单链表节点差不多，下面只列出了成员变量，没有列方法。
static class Entry<K,V> implements Map.Entry<K,V> {
final K key;
V value;
//下一个键值对
Entry<K,V> next;
//哈希值
int hash;
}
成员变量
//默认的初始桶数量
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;
/**
* 默认的空HashMap
*/
static final Entry<?,?>[] EMPTY_TABLE = {};
/**
* HashMap的底层实现，初始化为EMPTY_TABLE
*/
transient Entry<K,V>[] table = (Entry<K,V>[]) EMPTY_TABLE;
/**
* 键值对数量
*/
transient int size;
// 阈值，除了第一次初始化为DEFAULT_INITIAL_CAPACITY = 16，
// 其余为loadFactor*capacity（当前容量）
int threshold;
//负载因子,和rehash的阈值有关,默认的负载因子为0.75
final float loadFactor;
//这个变量记录HashMap增减键值对的次数，用于实现fail-fast机制
transient int modCount;
/**
*用于替代哈希值(和原哈希值做运算,作为新的哈希值,使哈希冲突更少),
*默认值为0(即不使用这项功能.)
*/
transient int hashSeed = 0;
hash()
这个方法就是上面 hashSeed替代哈希的方法. 当hashSeed为0是,返回的值等于k的哈希值.下面的方法多处有用到,这里提一下.
final int hash(Object k) {
int h = hashSeed;
if (0 != h && k instanceof String) {
return sun.misc.Hashing.stringHash32((String) k);
}
h ^= k.hashCode();
// This function ensures that hashCodes that differ only by
// constant multiples at each bit position have a bounded
// number of collisions (approximately 8 at default load factor).
h ^= (h >>> 20) ^ (h >>> 12);
return h ^ (h >>> 7) ^ (h >>> 4);
}
indexFor()
这个方法用于根据哈希值获取相应的桶的下标.
因为length即桶的数量为2的整数幂,所以
h & (length-1)就相当于对 length 取模(使用减法替代取模，提升计算效率)-
为了使不同 hash 值发生碰撞的概率更小，尽可能促使元素在哈希表中均匀地散列。
- length为2的整数幂,即为偶数,所以length-1的位数为1,那么
h & (length-1)就可能是奇数或偶数. - 若length为奇数,那么length-1的位数为0,那么
h & (length-1)就只能是偶数,有一半的桶被浪费了.
- length为2的整数幂,即为偶数,所以length-1的位数为1,那么
static int indexFor(int h, int length) {
return h & (length-1);
}
get(Object)
public V get(Object key) {
if (key == null)
return getForNullKey();
Entry<K,V> entry = getEntry(key);
return null == entry ? null : entry.getValue();
}
从这个方法可以看到根据key是否为null,分别调用了getEntry和getForNullKey.
-
getForNullKey- 从这个方法可以看出HashMap可存入{null,X}的键值对,而且key==null的哈希值为0.
private V getForNullKey() {
if (size == 0) {
return null;
}
for (Entry<K,V> e = table[0]; e != null; e = e.next) {
if (e.key == null)
return e.value;
}
return null;
}
-
getEntry方法实现很简单,首先根据哈希值直接找到键值对所在的桶,再对桶内的链表进行遍历,找到相应的键值对.
有一点注意,在方法中,判断键值对是否同一个的时候,首先对比hash值,然后对比是否同一个引用或
equals()是否为true.所以放入HashMap内的元素必须覆盖hashCode()和equals()方法。
final Entry<K,V> getEntry(Object key) {
if (size == 0) {
return null;
}
int hash = (key == null) ? 0 : hash(key);
for (Entry<K,V> e = table[indexFor(hash, table.length)];
e != null;
e = e.next) {
Object k;
if (e.hash == hash &&
((k = e.key) == key || (key != null && key.equals(k))))
return e;
}
return null;
}
put(K,V)
这个方法用于更新或加入键值对.可以看出可以分成四个部分
- 如果HashMap为空,调用
inflateTable(threshold)进行初始化 - 如果键值对为{null,X},调用
putForNullKey(value) - 根据哈希值找到相应桶,遍历桶内的链表找到相应的键值对,更新
- 如果找不到相应的键值对,在那个桶内加入新键值对
addEntry(hash, key, value, i)
public V put(K key, V value) {
if (table == EMPTY_TABLE) {
inflateTable(threshold);
}
if (key == null)
return putForNullKey(value);
int hash = hash(key);
int i = indexFor(hash, table.length);
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
if (e.hash == hash && ((k = e.key) == key || key.equals(k))) {
V oldValue = e.value;
e.value = value;
//这个调用没有意义
e.recordAccess(this);
return oldValue;
}
}
modCount++;
addEntry(hash, key, value, i);
return null;
}
- inflateTable(threshold)
返回一个初始化后的新桶数组,大小为2的整数幂N,且N>=原阈值
private void inflateTable(int toSize) {
// 返回2的整数幂N,且N>=number
int capacity = roundUpToPowerOf2(toSize);
//更新阈值
threshold = (int) Math.min(capacity * loadFactor, MAXIMUM_CAPACITY + 1);
table = new Entry[capacity];
//用于对hashSeed的调整,这里不用理会
initHashSeedAsNeeded(capacity);
}
//调用这个方法会返回2的整数幂N,且N>=number
//桶数量是2的整数幂
private static int roundUpToPowerOf2(int number) {
// assert number >= 0 : "number must be non-negative";
return number >= MAXIMUM_CAPACITY
? MAXIMUM_CAPACITY
: (number > 1) ? Integer.highestOneBit((number - 1) << 1) : 1;
}
- 当键值对存在时,无论key是否为null,都是根据哈希值找到桶,然后对桶内的链表遍历找到相应的键值对(和
get()差不多),然后更新value值.当找不到的时候,都是调用addEntry()插入新键值对
void addEntry(int hash, K key, V value, int bucketIndex) {
if ((size >= threshold) && (null != table[bucketIndex])) {
/触发桶扩充,下面再详细说这个函数.
resize(2 * table.length);
//重新计算哈希值和相应的桶的下标,
//因为扩充后,table.length变了,
//hash()的结果可能变化了(根据是否使用hashSeed)
hash = (null != key) ? hash(key) : 0;
bucketIndex = indexFor(hash, table.length);
}
createEntry(hash, key, value, bucketIndex);
}
//使用头插入法,把新插入的键值对放在头部
void createEntry(int hash, K key, V value, int bucketIndex) {
Entry<K,V> e = table[bucketIndex];
table[bucketIndex] = new Entry<>(hash, key, value, e);
size++;
}
从上面的代码可以看到,触发桶扩充的两个条件:
- 桶数量>=阈值
- 插入时发生了哈希冲突
每次桶扩充后,桶数量为原来的两倍
resize()
桶扩充的时间花费与桶和size的数量成正比.
void resize(int newCapacity) {
Entry[] oldTable = table;
int oldCapacity = oldTable.length;
if (oldCapacity == MAXIMUM_CAPACITY) {
threshold = Integer.MAX_VALUE;
return;
}
Entry[] newTable = new Entry[newCapacity];
//把原来的桶数组的元素全部移到新的桶数组,使用的头插法
transfer(newTable, initHashSeedAsNeeded(newCapacity));
table = newTable;
//设定新的阈值,为新桶数量*负载系数
threshold = (int)Math.min(newCapacity * loadFactor, MAXIMUM_CAPACITY + 1);
}
