首页 > 试题广场 >

Hashtable 和 HashMap 的区别是:

[不定项选择题]
Hashtable HashMap 的区别是:
  • Hashtable 是一个哈希表,该类继承了 AbstractMap,实现了 Map 接口
  • HashMap 是内部基于哈希表实现,该类继承AbstractMap,实现Map接口
  • Hashtable 线程安全的,而 HashMap 是线程不安全的
  • Properties 类 继承了 Hashtable 类,而 Hashtable 类则继承Dictionary 类
  • HashMap允许将 null 作为一个 entry 的 key 或者 value,而 Hashtable 不允许。
推荐
选B、C、D、E。
Hashtable
(1)Hashtable 是一个散列表,它存储的内容是键值对(key-value)映射。
(2)Hashtable 的函数都是同步的,这意味着它是线程安全的。它的key、value都不可以为null。
(3)HashTable直接使用对象的hashCode
HashMap:
(1)数组+链表组成的,基于哈希表的Map实现,数组是HashMap的主体,链表则是主要为了解决哈希冲突而存在的。
(2)不是线程安全的,HashMap可以接受为null的键(key)和值(value)
(3)HashMap重新计算hash值

Hashtable,HashMap,Properties继承关系如下:
public class Hashtable<K,V> extends Dictionary<K,V>
    implements Map<K,V>, Cloneable, java.io.Serializable


public class HashMap<K,V>extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable  
java.lang.Objecct 
  java.util.Dictionary<K,V> 
    java.util.Hashtable<Object,Object> 
      java.util.Properties 

编辑于 2019-04-26 14:54:35 回复(7)

C或者E,更倾向于C

A、×,Hashtable 是一个哈希表,该类继承自Dictionary类,实现了 Map 接口
B、×,HashMap是基于哈希表实现的,每一个元素是一个key-value对,其内部通过单链表解决冲突问题,容量不足(超过了阀值)时,同样会自动增长。该类继承AbstractMap,实现Map接口
C、 √,Hashtable 线程安全的,而 HashMap 是线程不安全的。Hashtable 中的方法是Synchronize的,而HashMap中的方法在缺省情况下是非Synchronize的。
D、讲的没错,但是不符合题意
E、语句挑不出毛病。

哈希值的使用不同,HashTable直接使用对象的hashCode。而HashMap重新计算hash值。

hashCode是jdk根据对象的地址或者字符串或者数字算出来的int类型的数值。

Hashtable计算hash值,直接用key的hashCode(),而HashMap重新计算了key的hash值,Hashtable在求hash值对应的位置索引时,用取模运算,而HashMap在求位置索引时,则用与运算,且这里一般先用hash&0x7FFFFFFF后,再对length取模,&0x7FFFFFFF的目的是为了将负的hash值转化为正值,因为hash值有可能为负数,而&0x7FFFFFFF后,只有符号外改变,而后面的位都不变。


HashTable和HashMap区别

1、继承的父类不同


Hashtable继承自Dictionary类,而HashMap继承自AbstractMap类。但二者都实现了Map接口。

2、线程安全性不同

javadoc中关于hashmap的一段描述如下:此实现不是同步的。如果多个线程同时访问一个哈希映射,而其中至少一个线程从结构上修改了该映射,则它必须保持外部同步。


Hashtable 中的方法是Synchronize的,而HashMap中的方法在缺省情况下是非Synchronize的。在多线程并发的环境下,可以直接使用Hashtable,不需要自己为它的方法实现同步,但使用HashMap时就必须要自己增加同步处理。(结构上的修改是指添加或删除一个或多个映射关系的任何操作;仅改变与实例已经包含的键关联的值不是结构上的修改。)这一般通过对自然封装该映射的对象进行同步操作来完成。如果不存在这样的对象,则应该使用 Collections.synchronizedMap 方法来“包装”该映射。最好在创建时完成这一操作,以防止对映射进行意外的非同步访问,如下所示:

Map m = Collections.synchronizedMap(new HashMap(...));

Hashtable 线程安全很好理解,因为它每个方法中都加入了Synchronize。这里我们分析一下HashMap为什么是线程不安全的:


HashMap底层是一个Entry数组,当发生hash冲突的时候,hashmap是采用链表的方式来解决的,在对应的数组位置存放链表的头结点。对链表而言,新加入的节点会从头结点加入。

我们来分析一下多线程访问:


(1)在hashmap做put操作的时候会调用下面方法:


[java] 
  1. // 新增Entry。将“key-value”插入指定位置,bucketIndex是位置索引。
  2. void addEntry(int hash, K key, V value, int bucketIndex) {
  3. // 保存“bucketIndex”位置的值到“e”中
  4. Entry<K,V> e = table[bucketIndex];
  5. // 设置“bucketIndex”位置的元素为“新Entry”,
  6. // 设置“e”为“新Entry的下一个节点”
  7. table[bucketIndex] = new Entry<K,V>(hash, key, value, e);
  8. // 若HashMap的实际大小 不小于 “阈值”,则调整HashMap的大小
  9. if (size++ >= threshold)
  10. resize(2 * table.length);
  11. }


在hashmap做put操作的时候会调用到以上的方法。现在假如A线程和B线程同时对同一个数组位置调用addEntry,两个线程会同时得到现在的头结点,然后A写入新的头结点之后,B也写入新的头结点,那B的写入操作就会覆盖A的写入操作造成A的写入操作丢失

( 2)删除键值对的代码


[java]
  1. <span style="font-size: 18px;">      </span>// 删除“键为key”的元素
  2. final Entry<K,V> removeEntryForKey(Object key) {
  3. // 获取哈希值。若key为null,则哈希值为0;否则调用hash()进行计算
  4. int hash = (key == null) ? 0 : hash(key.hashCode());
  5. int i = indexFor(hash, table.length);
  6. Entry<K,V> prev = table[i];
  7. Entry<K,V> e = prev;
  8. // 删除链表中“键为key”的元素
  9. // 本质是“删除单向链表中的节点”
  10. while (e != null) {
  11. Entry<K,V> next = e.next;
  12. Object k;
  13. if (e.hash == hash &&
  14. ((k = e.key) == key || (key != null && key.equals(k)))) {
  15. modCount++;
  16. size--;
  17. if (prev == e)
  18. table[i] = next;
  19. else
  20. prev.next = next;
  21. e.recordRemoval(this);
  22. return e;
  23. }
  24. prev = e;
  25. e = next;
  26. }
  27. return e;
  28. }


当多个线程同时操作同一个数组位置的时候,也都会先取得现在状态下该位置存储的头结点,然后各自去进行计算操作,之后再把结果写会到该数组位置去,其实写回的时候可能其他的线程已经就把这个位置给修改过了,就会覆盖其他线程的修改

(3)addEntry中当加入新的键值对后键值对总数量超过门限值的时候会调用一个resize操作,代码如下:

[java]
  1. // 重新调整HashMap的大小,newCapacity是调整后的容量
  2. void resize(int newCapacity) {
  3. Entry[] oldTable = table;
  4. int oldCapacity = oldTable.length;
  5. //如果就容量已经达到了最大值,则不能再扩容,直接返回
  6. if (oldCapacity == MAXIMUM_CAPACITY) {
  7. threshold = Integer.MAX_VALUE;
  8. return;
  9. }
  10. // 新建一个HashMap,将“旧HashMap”的全部元素添加到“新HashMap”中,
  11. // 然后,将“新HashMap”赋值给“旧HashMap”。
  12. Entry[] newTable = new Entry[newCapacity];
  13. transfer(newTable);
  14. table = newTable;
  15. threshold = (int)(newCapacity * loadFactor);
  16. }

这个操作会新生成一个新的容量的数组,然后对原数组的所有键值对重新进行计算和写入新的数组,之后指向新生成的数组。


当多个线程同时检测到总数量超过门限值的时候就会同时调用resize操作,各自生成新的数组并rehash后赋给该map底层的数组table,结果最终只有最后一个线程生成的新数组被赋给table变量,其他线程的均会丢失。而且当某些线程已经完成赋值而其他线程刚开始的时候,就会用已经被赋值的table作为原始数组,这样也会有问题。

3、是否提供contains方法


HashMap把Hashtable的contains方法去掉了,改成containsValue和containsKey,因为contains方法容易让人引起误解。

Hashtable则保留了contains,containsValue和containsKey三个方法,其中contains和containsValue功能相同。

我们看一下Hashtable的ContainsKey方法和ContainsValue的源码:

[java]
  1. public boolean containsValue(Object value) {
  2. return contains(value);
  3. }

[java]
  1. // 判断Hashtable是否包含“值(value)”
  2. public synchronized boolean contains(Object value) {
  3. //注意,Hashtable中的value不能是null,
  4. // 若是null的话,抛出异常!
  5. if (value == null) {
  6. throw new NullPointerException();
  7. }
  8. // 从后向前遍历table数组中的元素(Entry)
  9. // 对于每个Entry(单向链表),逐个遍历,判断节点的值是否等于value
  10. Entry tab[] = table;
  11. for (int i = tab.length ; i-- > 0 ;) {
  12. for (Entry<K,V> e = tab[i] ; e != null ; e = e.next) {
  13. if (e.value.equals(value)) {
  14. return true;
  15. }
  16. }
  17. }
  18. return false;
  19. }


[java]
  1. // 判断Hashtable是否包含key
  2. public synchronized boolean containsKey(Object key) {
  3. Entry tab[] = table;
  4. /计算hash值,直接用key的hashCode代替
  5. int hash = key.hashCode();
  6. // 计算在数组中的索引值
  7. int index = (hash & 0x7FFFFFFF) % tab.length;
  8. // 找到“key对应的Entry(链表)”,然后在链表中找出“哈希值”和“键值”与key都相等的元素
  9. for (Entry<K,V> e = tab[index] ; e != null ; e = e.next) {
  10. if ((e.hash == hash) && e.key.equals(key)) {
  11. return true;
  12. }
  13. }
  14. return false;
  15. }

下面我们看一下HashMap的ContainsKey方法和ContainsValue的源码:

[java]
  1. // HashMap是否包含key
  2. public boolean containsKey(Object key) {
  3. return getEntry(key) != null;
  4. }

[java]
  1. // 返回“键为key”的键值对
  2. final Entry<K,V> getEntry(Object key) {
  3. // 获取哈希值
  4. // HashMap将“key为null”的元素存储在table[0]位置,“key不为null”的则调用hash()计算哈希值
  5. int hash = (key == null) ? 0 : hash(key.hashCode());
  6. // 在“该hash值对应的链表”上查找“键值等于key”的元素
  7. for (Entry<K,V> e = table[indexFor(hash, table.length)];
  8. e != null;
  9. e = e.next) {
  10. Object k;
  11. if (e.hash == hash &&
  12. ((k = e.key) == key || (key != null && key.equals(k))))
  13. return e;
  14. }
  15. return null;
  16. }

[java]
  1. // 是否包含“值为value”的元素
  2. public boolean containsValue(Object value) {
  3. // 若“value为null”,则调用containsNullValue()查找
  4. if (value == null)
  5. return containsNullValue();
  6. // 若“value不为null”,则查找HashMap中是否有值为value的节点。
  7. Entry[] tab = table;
  8. for (int i = 0; i < tab.length ; i++)
  9. for (Entry e = tab[i] ; e != null ; e = e.next)
  10. if (value.equals(e.value))
  11. return true;
  12. return false;
  13. }

通过上面源码的比较,我们可以得到第四个不同的地方


4、key和value是否允许null值


其中key和value都是对象,并且不能包含重复key,但可以包含重复的value。

通过上面的ContainsKey方法和ContainsValue的源码我们可以很明显的看出:

Hashtable中,key和value都不允许出现null值。但是如果在Hashtable中有类似put(null,null)的操作,编译同样可以通过,因为key和value都是Object类型,但运行时会抛出NullPointerException异常,这是JDK的规范规定的。
HashMap中,null可以作为键,这样的键只有一个;可以有一个或多个键所对应的值为null。当get()方法返回null值时,可能是 HashMap中没有该键,也可能使该键所对应的值为null。因此,在HashMap中不能由get()方法来判断HashMap中是否存在某个键, 而应该用containsKey()方法来判断。

5、两个遍历方式的内部实现上不同

Hashtable、HashMap都使用了 Iterator。而由于历史原因,Hashtable还使用了Enumeration的方式 。

6、hash值不同

哈希值的使用不同,HashTable直接使用对象的hashCode。而HashMap重新计算hash值。

hashCode是jdk根据对象的地址或者字符串或者数字算出来的int类型的数值。

Hashtable计算hash值,直接用key的hashCode(),而HashMap重新计算了key的hash值,Hashtable在求hash值对应的位置索引时,用取模运算,而HashMap在求位置索引时,则用与运算,且这里一般先用hash&0x7FFFFFFF后,再对length取模,&0x7FFFFFFF的目的是为了将负的hash值转化为正值,因为hash值有可能为负数,而&0x7FFFFFFF后,只有符号外改变,而后面的位都不变。

7、内部实现使用的数组初始化和扩容方式不同

HashTable在不指定容量的情况下的默认容量为11,而HashMap为16,Hashtable不要求底层数组的容量一定要为2的整数次幂,而HashMap则要求一定为2的整数次幂。
Hashtable扩容时,将容量变为原来的2倍加1,而HashMap扩容时,将容量变为原来的2倍。

Hashtable和HashMap它们两个内部实现方式的数组的初始大小和扩容的方式。HashTable中hash数组默认大小是11,增加的方式是 old*2+1。

编辑于 2019-04-25 20:59:10 回复(13)
HashTable和HashMap的区别(7点):
1.继承的父类不同:HashTable继承Dictory类,HashMap继承AbstractMap.但都实现了Map接口;
2.线程安全性不同:HashTable是线程安全的,适用于多线程;HashMap是非线程安全,更适合于单线程;
3.是否提供contains方法:HashTable中保留了contains方法,与constainsValue功能相同;HashMap中去掉了contains方法;
4.key和value是否可为null值:HashTable的key、value都不允许null值;HashMap,null可以作为key;
5.遍历方式的内部实现不同:HashTable、HashMap都使用了Iterator,HashTable还使用过Enumeration方式;
6.hash值不同:HashTable直接使用对象的hashCode,而HashMap重新计算hash值。
7.内部使用的数组初始化和扩容方式不同:Hashtable不要求底层数组的容量一定要为2的整数次幂,而HashMap则要求一定为2的整数次幂;Hashtable扩容时,将容量变为原来的2倍加1,而HashMap扩容时,将容量变为原来的2倍。
发表于 2020-03-26 23:04:44 回复(0)
发表于 2022-01-14 16:46:07 回复(0)

答案:bcd+e? E不太确定的原因见下文描述。

就像要看懂《复仇者联盟4》和《权力的游戏8》一样,咱先从脉络来分析,先看图

这里写图片描述

这里写图片描述

就发现,这两货继承的类不同,但是都实现了map接口。所以a错,b对。

从线程安全的角度来看:

Hashtable是线程安全的,它的每个方法中都加入了Synchronize方法。在多线程并发的环境下,可以直接使用Hashtable,不需要自己为它的方法实现同步

HashMap不是线程安全的,在多线程并发的环境下,可能会产生死锁等问题。具体的原因在下一篇文章中会详细进行分析。使用HashMap时就必须要自己增加同步处理,

虽然HashMap不是线程安全的,但是它的效率会比Hashtable要好很多。这样设计是合理的。在我们的日常使用当中,大部分时间是单线程操作的。HashMap把这部分操作解放出来了。当需要多线程操作的时候可以使用线程安全的ConcurrentHashMap。ConcurrentHashMap虽然也是线程安全的,但是它的效率比Hashtable要高好多倍。因为ConcurrentHashMap使用了分段锁,并不对整个数据进行锁定。
所以C对。

再来看看Properties的继承关系,发现d是对的。

java.util
类 Properties
java.lang.Object
java.util.Dictionary
java.util.Hashtable
java.util.Properties

最后一个选项,我们看一下hashcode到底怎么算出来的:

HashMap使用自己的计算hash的方法(会依赖key的hashCode方法),HashTable则使用key的hashCode方法得到。

这个对象指的是key,还是value?

我相信出题者的初衷是根据key的hashCode来计算的意思。

发表于 2019-04-25 15:50:06 回复(0)
hashtable:线程安全;继承dictionary;不允许null值
hashmap:线程不安全;继承abstractmap;允许value为null
发表于 2021-03-06 14:53:12 回复(0)
bcd
发表于 2017-04-08 10:46:15 回复(1)

Hashtable是一个散列表,键值对,key和value不能为null,线性安全

HashMap由数组加链表组成,基于哈希表的Map实现,数组是其主体,链表则主要为了解决哈希冲突而存在,链值可以为null,不是线性安全

编辑于 2019-09-17 10:05:44 回复(0)
C
Hashtable继承与Dictionary类,而Hashmap实现了map接口;
Hashtable线程安全,不允许有null的键或者值,方法是Synchronize的,Hashmap则与其相反。




发表于 2017-02-15 18:51:51 回复(0)

发表于 2021-01-28 09:42:50 回复(0)
hashtable继承和实现关系如下图。hashtable继承的是dictionary类,不是abstractMap。

hashtable不能设置value为null的。  hashmap对key,v没有限制。


properties继承的是hashtable接口,间接的实现了map接口

发表于 2022-09-27 09:35:39 回复(0)
(1)Hashtable 是一个散列表,它存储的内容是键值对(key-value)映射。 (2)Hashtable 的函数都是同步的,这意味着它是线程安全的。它的key、value都不可以为null。 (3)HashTable直接使用对象的hashCode。 HashMap: (1)由数组+链表组成的,基于哈希表的Map实现,数组是HashMap的主体,链表则是主要为了解决哈希冲突而存在的。 (2)不是线程安全的,HashMap可以接受为null的键(key)和值(value)。 (3)HashMap重新计算hash值 Hashtable,HashMap,Properties继承关系如下: public class Hashtable<k> extends Dictionary<k> implements Map<k>, Cloneable, java.io.Serializable public class HashMap<k>extends AbstractMap<k> implements Map<k>, Cloneable, Serializable java.lang.Objecct java.util.Dictionary<k> java.util.Hashtable<object> java.util.Properties </object></k></k></k></k></k></k></k>
发表于 2021-11-09 14:37:00 回复(0)
直接选C就行了啊其他的都不用看。
发表于 2019-04-26 14:12:56 回复(0)
hashtable继承自dictionary类,实现了map接口类 peoperties 继承了hashtable
编辑于 2024-02-17 00:01:32 回复(0)

选项A: Hashtable继承了Dictionary,实现Map接口

public class Hashtable<K,V> extends Dictionary<K,V> implements Map<K,V>, Cloneable, java.io.Serializable { }

选项B: 正确

public class HashMap<K,V> extends AbstractMap<K,V> implements Map<K,V>, Cloneable, Serializable {      }

选项C: 正确

选项D: 正确

public class Properties extends Hashtable<Object,Object> { }

选项E:正确

Hashtable的key、value都不可以为null  HashMap可以接受为null的键(key)和值(value)

总结HashTableHashMap的区别(8点):

1. 继承的父类不同:HashTable继承Dictory类,HashMap继承AbstractMap.但都实现了Map接口;

2. 线程安全性不同:HashTable是线程安全的,适用于多线程;HashMap是非线程安全,更适合于单线程;

3. 是否提供contains方法:HashTable中保留了contains方法,与constainsValue功能相同;HashMap中去掉了contains方法;

4. key和value是否可为null值:HashTable的key、value都不允许null值;HashMap,null可以作为key;

5. 遍历方式的内部实现不同:HashTable、HashMap都使用了Iterator,HashTable还使用过Enumeration方式;

6. hash值不同:HashTable直接使用对象的hashCode,而HashMap重新计算hash值。

7. 内部使用的数组初始化和扩容方式不同:Hashtable不要求底层数组的容量一定要为2的整数次幂,而HashMap则要求一定为2的整数次幂;Hashtable扩容时,将容量变为原来的2倍加1,而HashMap扩容时,将容量变为原来的2倍。

8. 底层数据结构不同:Hashtable 和 JDK 1.7 版本的 HashMap 底层数据结构相同,都是基于数组和链表的组合。具体来说,它们使用一个数组作为主要存储结构,并通过哈希算法将键映射到数组的索引位置。当发生哈希冲突时,多个键可能被映射到同一个索引位置,此时将使用链表来解决冲突。这意味着具有相同索引位置的键值对将按照插入顺序以链表形式存储。JDK 1.8 版本的 HashMap 进行了优化,当链表长度超过一定阈值(默认为8)时,会将链表转换为红黑树。这是为了提高在链表过长时的查询、插入和删除操作的性能。红黑树作为一种自平衡的二叉搜索树,可以在最坏情况下保持 O(log n) 的时间复杂度。因此,在 JDK 1.8 及其之后的版本中,HashMap 采用了数组加链表/红黑树的结构,而 Hashtable 仍然使用数组加链表的结构

编辑于 2023-10-09 08:54:50 回复(0)
public class Hashtable<K,V> extends Dictionary<K,V> 
public class HashMap<K,V>extends AbstractMap<K,V>
发表于 2023-05-29 10:11:41 回复(0)
dictionary《-----hashtable《------properties
发表于 2023-03-17 14:28:03 回复(0)
A选项错的地方在于,Hashtable继承了Dictionary类而不是AbstractMap
发表于 2022-11-12 15:56:31 回复(0)
D 虽然是对的,但也不是区别呀(・∀・*)
发表于 2022-10-23 09:53:23 回复(0)
D选项也算hashMap和hashtable的区别吗?
发表于 2022-10-09 14:53:49 回复(0)
Hashtable继承的是Dictionary
发表于 2022-08-16 22:12:51 回复(0)