记得刚毕业那会准备面试,看过不少面试题,里面有个说出HashMap和HashTable不同的题目,我那会面试的时候也遇到不少次这个问题,还隐约记得当时的回答是这样的:
HashTable是比较旧的版本;HashTable是线程安全的,而HashMap是非线程安全的;HashMap的key和value允许Null值,还有就是HashMap效率要高。好像就这些了吧,当时认识也比较肤浅。
前段时间有空就想起来了这个问题,于是就想深入的理解一下这两个比较常用的数据结构,然后看了一下这两个类的源码,有了比以前更深入的了解。大体上这两个类内部处理差别不是很大,当然还是有不少不同,下面我们来一一探讨一下他们之间的不同
引言:首先来说一下HashMap内部其实是一个数组+链表的结构,当你put一个元素的时候,HashMap会根据Key的hash值算出要存放的数组的位置,如果两个元素算出的数组值相同的话,那么他们会放在数组里的同一个位置,这个时候在获取该元素的时候,那么会根据Key的hash找到数组的位置,然后再从链表中找到该元素。那么我们可以很容易的想象到,如果每一个数组里只有一个元素的时候,效率是最高的,因为不需要再对链表进行操作。有了这点认识我们就可以进行接下来的分析了。
[list]
[1]数组大小 。
既然说了内部是数组+链表,那就设计到数组的大小,这一点,HashMap和HashTable是不同的
HashMap的默认大小
Java代码
static final int DEFAULT_INITIAL_CAPACITY = 16 ;
static final int DEFAULT_INITIAL_CAPACITY = 16;
我们看到默认是16,而且HashMap的大小一定是2的幂数。这里你可能会问了,如果初始化HashMap的时候指定了一个不是2的幂数的长度呢?如果是这种情况,它也会找到一个最接近你指定值的一个2的幂数,下面是源码:
Java代码
int capacity = 1 ;
while (capacity < initialCapacity)
capacity <<= 1 ;
int capacity = 1;
while (capacity < initialCapacity)
capacity <<= 1;
就是他会找到一个比你指定值大且是2的幂数的一个值,那么为什么它会这么做呢,这个问题我留到下面具体说明。
HashMap长度最大值也是有设定的,他的最大值是
Java代码
static final int MAXIMUM_CAPACITY = 1 << 30 ;
static final int MAXIMUM_CAPACITY = 1 << 30;
如果你指定超过这个大小,它会抛弃你指定的值而采用这个默认值
Java代码
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
if (initialCapacity > MAXIMUM_CAPACITY)
initialCapacity = MAXIMUM_CAPACITY;
HashTable的默认大小
Java代码
public Hashtable() {
this ( 11 , 0 .75f);
}
public Hashtable() {
this(11, 0.75f);
}
默认是11,HashTable跟HashMap不同如果你指定了长度,它不会对你的指定值进行处理。HashTable的最大值,我没看有看到HashTable中有指定最大值的行为
[2]长度扩容
上面我们讲了两个类的初始大小,这里需要说明的事,在实际中真正利用的长度并不是这个值,而是有个加载因子,默认是0.75,比如长度是16,而真正使用的是16*0.75,当超过这个数,就会扩容
HashMap扩容
HashMap扩容会把之前长度*2,因为之前的长度肯定是2的幂数,所以自动扩容后也是2的幂数
HashTable扩容
HashTable扩容是把之前长度*2+1
扩容操作是比较消耗资源的,所以这里我们告诉我们在初始化HashMap和HashTable的时候要考虑到实际使用时的长度,应该尽可能的避免出现扩容的操作,从而提高效率
[3]put操作
HashMap的put
Java代码
public V put(K key, V value) {
K k = maskNull(key);
int hash = hash(k);
int i = indexFor(hash, table.length);
for (Entry<K,V> e = table[i]; e != null ; e = e.next) {
if (e.hash == hash && eq(k, e.key)) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this );
return oldValue;
}
}
modCount++;
addEntry(hash, k, value, i);
return null ;
}
public V put(K key, V value) {
K k = maskNull(key);
int hash = hash(k);
int i = indexFor(hash, table.length);
for (Entry<K,V> e = table[i]; e != null; e = e.next) {
if (e.hash == hash && eq(k, e.key)) {
V oldValue = e.value;
e.value = value;
e.recordAccess(this);
return oldValue;
}
}
modCount++;
addEntry(hash, k, value, i);
return null;
}
我们看到首先进行maskNull,这也是为什么HashMap允许有null键;
然后是计算hash值,下面是hash方法
Java代码
static int hash(Object x) {
int h = x.hashCode();
h += ~(h << 9 );
h ^= (h >>> 14 );
h += (h << 4 );
h ^= (h >>> 10 );
return h;
}
static int hash(Object x) {
int h = x.hashCode();
h += ~(h << 9);
h ^= (h >>> 14);
h += (h << 4);
h ^= (h >>> 10);
return h;
}
这里HashMap对hash值进行处理,进行了一些列的操作,目的是为了让hash值的高位参与接下来的运算,至于为什么要用到 9,14,4,10这几个数,我也不明白,我曾经给JDK的作者之一道格发过邮件咨询这个问题,他没有给我正面的回答,而是建议我看一本书中的hash那一章节,在我查找该问题的时候,发现国外很多人也向道格咨询过此问题,得到的回到好像跟我得到的回答是一样的,嘿嘿。好了,不说题外话了,反正大家知道经过这么操作我们到了一个非负整数。接下来是计算数组下标indexFor
Java代码
static int indexFor( int h, int length) {
return h & (length- 1 );
}
static int indexFor(int h, int length) {
return h & (length-1);
}
这里的 h & (length-1)是比较出彩的地方,也是为什么前面我们介绍HashMap长度的时候,他总是2的幂数,现在我们知道为什么了吧,它实现了 h & (length-1)等价于h % length的操作,求与比求模效率要高,在道格给我的回信中也提到了这一点。也许有人会问了,这里求与的操作中hash的高位没有参与到运算,那么当 hash值高位不同时,算出的index却是相同的,那么也就是说增加了在数组中相同位置存放的对象的几率,sun其实考虑到这个问题了,这就是我前面提到的那个hash方法,这也是我向道格发邮件的原因。
put方法接下来的代码就比较简单了,大家可以自己看,提一句就是put也是有返回值的如果你存放相同的Key的话返回旧的value值,如果是不同的key返回null
HashTable的put
Java代码
public synchronized V put(K key, V value) {
// Make sure the value is not null
if (value == null ) {
throw new NullPointerException();
}
// Makes sure the key is not already in the hashtable.
Entry tab[] = table;
int hash = key.hashCode();
int index = (hash & 0x7FFFFFFF ) % tab.length;
for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) {
if ((e.hash == hash) && e.key.equals(key)) {
V old = e.value;
e.value = value;
return old;
}
}
modCount++;
if (count >= threshold) {
// Rehash the table if the threshold is exceeded
rehash();
tab = table;
index = (hash & 0x7FFFFFFF ) % tab.length;
}
// Creates the new entry.
Entry<K,V> e = tab[index];
tab[index] = new Entry<K,V>(hash, key, value, e);
count++;
return null ;
}
public synchronized V put(K key, V value) {
// Make sure the value is not null
if (value == null) {
throw new NullPointerException();
}
// Makes sure the key is not already in the hashtable.
Entry tab[] = table;
int hash = key.hashCode();
int index = (hash & 0x7FFFFFFF) % tab.length;
for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) {
if ((e.hash == hash) && e.key.equals(key)) {
V old = e.value;
e.value = value;
return old;
}
}
modCount++;
if (count >= threshold) {
// Rehash the table if the threshold is exceeded
rehash();
tab = table;
index = (hash & 0x7FFFFFFF) % tab.length;
}
// Creates the new entry.
Entry<K,V> e = tab[index];
tab[index] = new Entry<K,V>(hash, key, value, e);
count++;
return null;
}
我这里首先就是发现该put是同步的,这是和HashMap的不同。还有这里没有对hash进行处理,而是直接用hash值,在计算数组下标的时候也和HashMap不同,他这里就是采用了普通的求模操作,在求模之前对hash值进行取绝对值操作,保证计算出来的下标是正的;我们可以看出差别了,单从计算下标这一点,HashMap是比HashTable有优化的。
这里我们再来总结一下:HashMap对hash值进行了处理(处理的目的:1是为了得到一个正数,另外一个是为了在进行接下来indexFor 计算时尽可能的得到均匀的下标值);HashTable没有对hash值进行处理,只是简单的进行了一下hash & 0x7FFFFFFF操作(取绝对值);HashMap在进行index计算是使用了求与,而Hashtable采用了求模,HashMap之所以可以采用求与来替代求模前提是建立在数组长度总是2的幂数上,我们可以这么说HashMap采用了2的幂数的长度和求与的结合达到了HashTable中求模的效果,从而提高了效率。