1.HashMap的实现原理
简单地说,HashMap就是将key做hash算法,然后将hash值映射到内存地址,直接取得key所对应的数据。在HashMap中,底层数据结构使用的是数组,所谓的内存地址即数组的下标索引。afHashMap的高性能需要保证以下几点:
-
hash算法必须是高效的
-
hash值到内存地址(数组索引)的算法是快速的
- 根据内存地址(数组索引)可以直接取得对应的值
首先来看第一点,hash算法的高效性。在HashMap中,hash算法有关的代码如下:
1 int hash = hash(key.hashCode());
2 public native int hashCode();
3 static int hash(int h) {
4 h ^= (h >>> 20) ^ (h >>> 12);
5 return h ^ (h >>> 7) ^ (h >>> 4);
6 }
第一行代码是HashMap中用于计算key的hash值。它前后分别调用了Object类的hashCode()方法和HashMap的内部函数hash()。Object类的hashCode()方法默认是native的实现,可以认为不存在性能问题。而hash()函数的实现全部基于位运算,因此,也是高效的。
注意:native方法通常比一般的方法快,因为它直接调用操作系统本地链接库的API。由于hashCode()方法是可以重载的,因此,为了保证HashMap的性能,需要确保相关的hashCode()是高效的。而位运算也比算术、逻辑运算快。
当取得key的hash值后,需要通过hash值得到内存地址:
int i = indexFor(hash, table.length);
static int indexFor(int h, int length) {
return h & (length-1);
}
indexFor()函数通过将hash值和数组长度按位取与直接得到数组索引。
最后由indexFor()函数返回的数组索引直接通过数组下标便可取得对应的值。直接的内存访问速度也相当快。因此,可以认为HashMap是高性能的。
2.Hash冲突
虽然上节中阐述了在理想情况下HashMap的高效性,但我们依然不得不在实际使用中考虑HashMap的一些特殊情况,这些情况有可能给HashMap带来一定的性能问题。其中,最值得关注便是hash冲突。如图3.11所示,需要存放到HashMap中的两个元素1和2,通过hash计算后,发现对应在内存中的同一个地址。此时,HashMap又会如何处理,以保证数据可以完整存放,并正常工作呢?
图3.11 Hash冲突示意图
要处理好这个问题,需要进一步深入HashMap,虽然HashMap的底层实现使用的是数组,但是数组内的元素并不是简单的值,而是一个Entry类的对象。因此,对HashMap结构的贴切描述如图3.12所示。
图3.12 HashMap表项结构
可以看到,HashMap的内部维护着一个Entry数组,每一个Entry表项包括key、value、next和hash几项。这里特别注意其中的next部分,他指向了另外一个Entry(所以实际上HashMap的数据结构是一个列表数组,数组中每个元素是一个Entry列表,Entry列表中每个元素是一个Entry对象)。进一步阅读HashMap的put()方法源码,可以看到当put()操作有冲突时,新的Entry依然会被安放在对应的索引下标内,并替换原有的值。同时,为了保证旧值不丢失,会将新的Entry的next指向旧值。这便实现了在一个数组索引空间内,存放多个值项。因此,如图3.12所示,HashMap实际上是一个链表为元素的数组。
public V put(K key, V value) {
if (key == null)
return putForNullKey(value);
int hash = hash(key.hashCode());
int i = indexFor(hash, table.length);
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
Object k;
//如果当前的key已经存在于HashMap中
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); //添加当前的表项到i位置
return null;
}
addEntry()方法的实现如下:
void addEntry(int hash, K key, V value, int bucketIndex) {
Entry<K,V> e = table[bucketIndex];
//将新增元素放到i的位置,并让它的next指向旧的元素
table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
if (size++ >= threshold)
resize(2 * table.length);
}
基于HashMap的这种实现机制,只要hashCode()和hash()方法实现的足够好,能够尽可能的减少冲突的产生,那么对HashMap的操作几乎等价于对数组的随机访问操作,具有很好的性能。但是,如果hashCode()或者hash()方法实现较差,在大量冲突产生的情况下,HashMap事实上就退化为几个链表,对HashMap的操作等价于遍历链表,此时性能很差。
考虑一个在极端情况下的例子,假设类BadHash有着一个很槽糕的hashCode()实现:
public class BadHash{
double d;
public BadHash(double d){
this.d=d;
}
@Override
public int hashCode(){
return 1; //一个槽糕的hashCode()实现
}
}
类GoodHash拥有默认hashCode()方法:
public class GoodHash{
double d;
public GoodHash(double d){
this.d=d;
}
}
分别使用BadHash类和GoodHash类作为HashMap的key,产生1万一个对象并将其存入HashMap中,执行get()方法1万次。结果BadHash类相对耗时1297ms,而GoodHash类仅耗时15ms。这正是随机数据访问和链表遍历的性能差距。
再补充一下HashMap的get(key)方法的实现原理解析:
public V get(Object key) {
if (key == null) // 键为null的Entry是tables[0]
return getForNullKey();
// 首先根据key获取hash值,跟put方法一致
int hash = hash(key.hashCode());
// 同样通过位与运算获取Entry[] tables下标
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.equals(k)))
// 当匹配到hash值相同,key相同的Entry元素时,返回Entry对象的vlaue
return e.value;
}
return null;
}