java hashmap继承什么区别(java中Hashtable和HashMap的区别分析)

大家好,今天小编来为大家解答以下的问题，关于java hashmap继承什么区别，java中Hashtable和HashMap的区别分析这个很多人还不知道，现在让我们一起来看看吧！

java中Hashtable和HashMap的区别分析

1 HashMap不是线程安全的

hastmap是一个接口是map接口的子接口，是将键映射到值的对象，其中键和值都是对象，并且不能包含重复键，但可以包含重复值。HashMap允许null key和null value，而hashtable不允许。

2 HashTable是线程安全的一个Collection。

HashMap是Hashtable的轻量级实现（非线程安全的实现），他们都完成了Map接口，主要区别在于HashMap允许空（null）键值（key）,由于非线程安全，效率上可能高于Hashtable。

HashMap允许将null作为一个entry的key或者value，而Hashtable不允许。

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

Hashtable继承自Dictionary类，而HashMap是Java1.2引进的Map interface的一个实现。

最大的不同是，Hashtable的方法是Synchronize的，而HashMap不是，在多个线程访问Hashtable时，不需要自己为它的方法实现同步，而HashMap就必须为之提供外同步。

Hashtable和HashMap采用的hash/rehash算法都大概一样，所以性能不会有很大的差异。

public static void main(String args[])

{

HashTable h=new HashTable();

h.put("用户1",new Integer(90));

h.put("用户2",new Integer(50));

h.put("用户3",new Integer(60));

h.put("用户4",new Integer(70));

h.put("用户5",new Integer(80));

Enumeration e=h.elements();

while(e.hasMoreElements()){

System.out.println(e.nextElement());

}

map的方法：

clear()从 Map中删除所有映射

remove(Object key)从 Map中删除键和关联的值

put(Object key, Object value)将指定值与指定键相关联

get(Object key)返回与指定键关联的值

containsKey(Object key)如果 Map包含指定键的映射，则返回 true

containsValue(Object value)如果此 Map将一个或多个键映射到指定值，则返回 true

isEmpty()如果 Map不包含键-值映射，则返回 true size()返回 Map中的键-值映射的数目

这些都代表了Java中的集合，这里主要从其元素是否有序，是否可重复来进行区别记忆，以便恰当地使用，当然还存在同步方面的差异，见上一篇相关文章。

有序否

允许元素重复否

Collection

否

是

List

是

是

Set

AbstractSet

否

否

HashSet

TreeSet

是（用二叉树排序）

Map

AbstractMap

否

使用key-value来映射和存储数据，Key必须惟一，value可以重复

HashMap

TreeMap

是（用二叉树排序）

List接口对Collection进行了简单的扩充，它的具体实现类常用的有ArrayList和LinkedList。你可以将任何东西放到一个List容器中，并在需要时从中取出。ArrayList从其命名中可以看出它是一种类似数组的形式进行存储，因此它的随机访问速度极快，而LinkedList的内部实现是链表，它适合于在链表中间需要频繁进行插入和删除操作。在具体应用时可以根据需要自由选择。前面说的Iterator只能对容器进行向前遍历，而 ListIterator则继承了Iterator的思想，并提供了对List进行双向遍历的方法。

Set接口也是 Collection的一种扩展，而与List不同的时，在Set中的对象元素不能重复，也就是说你不能把同样的东西两次放入同一个Set容器中。它的常用具体实现有HashSet和TreeSet类。HashSet能快速定位一个元素，但是你放到HashSet中的对象需要实现hashCode()方法，它使用了前面说过的哈希码的算法。而TreeSet则将放入其中的元素按序存放，这就要求你放入其中的对象是可排序的，这就用到了集合框架提供的另外两个实用类Comparable和Comparator。一个类是可排序的，它就应该实现Comparable接口。有时多个类具有相同的排序算法，那就不需要在每分别重复定义相同的排序算法，只要实现Comparator接口即可。集合框架中还有两个很实用的公用类：Collections和 Arrays。Collections提供了对一个Collection容器进行诸如排序、复制、查找和填充等一些非常有用的方法，Arrays则是对一个数组进行类似的操作。

Map是一种把键对象和值对象进行关联的容器，而一个值对象又可以是一个Map，依次类推，这样就可形成一个多级映射。对于键对象来说，像Set一样，一个Map容器中的键对象不允许重复，这是为了保持查找结果的一致性;如果有两个键对象一样，那你想得到那个键对象所对应的值对象时就有问题了，可能你得到的并不是你想的那个值对象，结果会造成混乱，所以键的唯一性很重要，也是符合集合的性质的。当然在使用过程中，某个键所对应的值对象可能会发生变化，这时会按照最后一次修改的值对象与键对应。对于值对象则没有唯一性的要求。你可以将任意多个键都映射到一个值对象上，这不会发生任何问题（不过对你的使用却可能会造成不便，你不知道你得到的到底是那一个键所对应的值对象）。Map有两种比较常用的实现： HashMap和TreeMap。HashMap也用到了哈希码的算法，以便快速查找一个键，TreeMap则是对键按序存放，因此它便有一些扩展的方法，比如firstKey(),lastKey()等，你还可以从TreeMap中指定一个范围以取得其子Map。键和值的关联很简单，用pub(Object key,Object value)方法即可将一个键与一个值对象相关联。用get(Object key)可得到与此key对象所对应的值对象。

hashtable和hashmap有什么区别,共同之处、

Hashtable和HashMap有什么区别

1.Hashtable和HashMap有什么区别？

a.Hashtable是继承自陈旧的Dictionary类的，HashMap继承自AbstractMap类同时是Java 1.2引进的Map接口的一个实现。

b.也许最重要的不同是Hashtable的方法是同步的，而HashMap的方法不是。这就意味着，然你可以不用采取任何特殊的行为就可以在一个多线程的应用程序中用一个Hashtable，但你必须同样地为一个HashMap提供外同步。一个方便的方法就是利用Collections类的静态的synchronizedMap()方法，它创建一个线程安全的Map对象，并把它作为一个封装的对象来返回。这个对象的方法可以让你同步访问潜在的HashMap。这么做的结果就是当你不需要同步时，你不能切断Hashtable中的同步（比如在一个单线程的应用程序中），而且同步增加了很多处理费用。

c.第三点不同是，只有HashMap可以让你将空值作为一个表的条目的key或value。HashMap中只有一条记录可以是一个空的key，但任意数量的条目可以是空的value。这就是说，如果在表中没有发现搜索键，或者如果发现了搜索键，但它是一个空的值，那么get()将返回null。如果有必要，用containKey()方法来区别这两种情况。

d.HashMap去掉了Hashtable的contains方法，保留了containsValue和containsKey方法

e.Hashtable中hash数组默认大小是11，增加的方式是 old*2+1。HashMap中hash数组的默认大小是16，而且一定是2的指数

HashTable的应用非常广泛，HashMap是新框架中用来代替HashTable的类，也就是说建议使用HashMap，不要使用HashTable。可能你觉得HashTable很好用，为什么不用呢？这里简单分析他们的区别。1.HashTable的方法是同步的，HashMap未经同步，所以在多线程场合要手动同步HashMap这个区别就像Vector和ArrayList一样。2.HashTable不允许null值(key和value都不可以),HashMap允许null值(key和value都可以)。3.HashTable有一个contains(Object value)，功能和containsValue(Object value)功能一样。4.HashTable使用Enumeration，HashMap使用Iterator。以上只是表面的不同，它们的实现也有很大的不同。5.HashTable中hash数组默认大小是11，增加的方式是 old*2+1。HashMap中hash数组的默认大小是16，而且一定是2的指数。6.哈希值的使用不同，HashTable直接使用对象的hashCode，代码是这样的：int hash= key.hashCode();int index=(hash& 0x7FFFFFFF)% tab.length;而HashMap重新计算hash值，而且用与代替求模：int hash= hash(k);

int i= indexFor(hash, table.length);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 indexFor(int h, int length){

return h&(length-1);

}

以上只是一些比较突出的区别，当然他们的实现上还是有很多不同的，比如HashMap对null的操作。

Hashtable和HashMap的区别：

1.Hashtable是Dictionary的子类，HashMap是Map接口的一个实现类；

2.Hashtable中的方法是同步的，而HashMap中的方法在缺省情况下是非同步的。即是说，在多线程应用程序中，不用专门的操作就安全地可以使用Hashtable了；而对于HashMap，则需要额外的同步机制。但HashMap的同步问题可通过Collections的一个静态方法得到解决：

Map Collections.synchronizedMap(Map m)

这个方法返回一个同步的Map，这个Map封装了底层的HashMap的所有方法，使得底层的HashMap即使是在多线程的环境中也是安全的。

3.在HashMap中，null可以作为键，这样的键只有一个；可以有一个或多个键所对应的值为null。当get()方法返回null值时，即可以表示HashMap中没有该键，也可以表示该键所对应的值为null。因此，在HashMap中不能由get()方法来判断HashMap中是否存在某个键，而应该用containsKey()方法来判断。Hashtable继承自Dictionary类，而HashMap是Java1.2引进的Map interface的一个实现HashMap允许将null作为一个entry的key或者value，而Hashtable不允许还有就是，HashMap把Hashtable的contains方法去掉了，改成containsvalue和containsKey。因为contains方法容易让人引起误解。最大的不同是，Hashtable的方法是Synchronize的，而HashMap不是，在

多个线程访问Hashtable时，不需要自己为它的方法实现同步，而HashMap

就必须为之提供外同步。Hashtable和HashMap采用的hash/rehash算法都大概一样，所以性能不会有很大的差异。

Java中HashMap和TreeMap的区别深入理解

首先介绍一下什么是Map。

在数组中我们是通过数组下标来对其内容索引的，而在Map中我们通过对象来对对象进行索引，用来索引的对象叫做key，其对应的对象叫做value。这就是我们平时说的键值对。

HashMap通过hashcode对其内容进行快速查找，

而 TreeMap中所有的元素都保持着某种固定的顺序，

如果你需要得到一个有序的结果你就应该使用TreeMap（HashMap中元素的排列顺序是不固定的）。

HashMap非线程安全 TreeMap非线程安全

线程安全

在Java里，线程安全一般体现在两个方面：

1、多个thread对同一个java实例的访问（read和modify）不会相互干扰，它主要体现在关键字synchronized。如ArrayList和Vector，HashMap和Hashtable

（后者每个方法前都有synchronized关键字）。如果你在interator一个List对象时，其它线程remove一个element，问题就出现了。

2、每个线程都有自己的字段，而不会在多个线程之间共享。它主要体现在java.lang.ThreadLocal类，而没有Java关键字支持，如像static、transient那样。

1.AbstractMap抽象类和SortedMap接口

AbstractMap抽象类：(HashMap继承AbstractMap)覆盖了equals()和hashCode()方法以确保两个相等映射返回相同的哈希码。如果两个映射大小相等、包含同样的键且每个键在这两个映射中对应的值都相同，则这两个映射相等。映射的哈希码是映射元素哈希码的总和，其中每个元素是Map.Entry接口的一个实现。因此，不论映射内部顺序如何，两个相等映射会报告相同的哈希码。

SortedMap接口：（TreeMap继承自SortedMap）它用来保持键的有序顺序。SortedMap接口为映像的视图(子集)，包括两个端点提供了访问方法。除了排序是作用于映射的键以外，处理SortedMap和处理SortedSet一样。添加到SortedMap实现类的元素必须实现Comparable接口，否则您必须给它的构造函数提供一个Comparator接口的实现。TreeMap类是它的唯一一份实现。

2.两种常规Map实现

HashMap：基于哈希表实现。使用HashMap要求添加的键类明确定义了hashCode()和equals()[可以重写hashCode()和equals()]，为了优化HashMap空间的使用，您可以调优初始容量和负载因子。

(1)HashMap():构建一个空的哈希映像

(2)HashMap(Map m):构建一个哈希映像，并且添加映像m的所有映射

(3)HashMap(int initialCapacity):构建一个拥有特定容量的空的哈希映像

(4)HashMap(int initialCapacity, float loadFactor):构建一个拥有特定容量和加载因子的空的哈希映像

TreeMap：基于红黑树实现。TreeMap没有调优选项，因为该树总处于平衡状态。

(1)TreeMap():构建一个空的映像树

(2)TreeMap(Map m):构建一个映像树，并且添加映像m中所有元素

(3)TreeMap(Comparator c):构建一个映像树，并且使用特定的比较器对关键字进行排序

(4)TreeMap(SortedMap s):构建一个映像树，添加映像树s中所有映射，并且使用与有序映像s相同的比较器排序

3.两种常规Map性能

HashMap：适用于在Map中插入、删除和定位元素。

Treemap：适用于按自然顺序或自定义顺序遍历键(key)。

4.总结

HashMap通常比TreeMap快一点(树和哈希表的数据结构使然)，建议多使用HashMap，在需要排序的Map时候才用TreeMap。

importjava.util.HashMap;

importjava.util.Hashtable;

importjava.util.Iterator;

importjava.util.Map;

importjava.util.TreeMap;

publicclassHashMaps{

publicstaticvoidmain(String[]args){

Map<String,String>map=newHashMap<String,String>();

map.put("a","aaa");

map.put("b","bbb");

map.put("c","ccc");

map.put("d","ddd");

Iterator<String>iterator=map.keySet().iterator();

while(iterator.hasNext()){

Objectkey=iterator.next();

System.out.println("map.get(key)is:"+map.get(key));

}

//定义HashTable,用来测试

Hashtable<String,String>tab=newHashtable<String,String>();

tab.put("a","aaa");

tab.put("b","bbb");

tab.put("c","ccc");

tab.put("d","ddd");

Iterator<String>iterator_1=tab.keySet().iterator();

while(iterator_1.hasNext()){

Objectkey=iterator_1.next();

System.out.println("tab.get(key)is:"+tab.get(key));

}

TreeMap<String,String>tmp=newTreeMap<String,String>();

tmp.put("a","aaa");

tmp.put("b","bbb");

tmp.put("c","ccc");

tmp.put("d","cdc");

Iterator<String>iterator_2=tmp.keySet().iterator();

while(iterator_2.hasNext()){

Objectkey=iterator_2.next();

System.out.println("tmp.get(key)is:"+tmp.get(key));

}

}

}

运行结果如下：

map.get(key)is:ddd

map.get(key)is:bbb

map.get(key)is:ccc

map.get(key)is:aaa

tab.get(key)is:bbb

tab.get(key)is:aaa

tab.get(key)is:ddd

tab.get(key)is:ccc

tmp.get(key)is:aaa

tmp.get(key)is:bbb

tmp.get(key)is:ccc

tmp.get(key)is:cdc

HashMap的结果是没有排序的，而TreeMap输出的结果是排好序的。

下面就要进入本文的主题了。先举个例子说明一下怎样使用HashMap:

importjava.util.*;

publicclassExp1{

publicstaticvoidmain(String[]args){

HashMaph1=newHashMap();

Randomr1=newRandom();

for(inti=0;i<1000;i++){

Integert=newInteger(r1.nextInt(20));

if(h1.containsKey(t))

((Ctime)h1.get(t)).count++;

else

h1.put(t,newCtime());

}

System.out.println(h1);

}

}

classCtime{

intcount=1;

publicStringtoString(){

returnInteger.toString(count);

}

}

在HashMap中通过get()来获取value，通过put()来插入value，ContainsKey()则用来检验对象是否已经存在。可以看出，和ArrayList的操作相比，HashMap除了通过key索引其内容之外，别的方面差异并不大。

前面介绍了，HashMap是基于HashCode的，在所有对象的超类Object中有一个HashCode()方法，但是它和equals方法一样，并不能适用于所有的情况，这样我们就需要重写自己的HashCode()方法。下面就举这样一个例子：

importjava.util.*;

publicclassExp2{

publicstaticvoidmain(String[]args){

HashMaph2=newHashMap();

for(inti=0;i<10;i++)

h2.put(newElement(i),newFigureout());

System.out.println("h2:");

System.out.println("GettheresultforElement:");

Elementtest=newElement(5);

if(h2.containsKey(test))

System.out.println((Figureout)h2.get(test));

else

System.out.println("Notfound");

}

}

classElement{

intnumber;

publicElement(intn){

number=n;

}

}

classFigureout{

Randomr=newRandom();

booleanpossible=r.nextDouble()>0.5;

publicStringtoString(){

if(possible)

return"OK!";

else

return"Impossible!";

}

}

在这个例子中，Element用来索引对象Figureout,也即Element为key，Figureout为value。在Figureout中随机生成一个浮点数，如果它比0.5大，打印”OK!”，否则打印”Impossible!”。之后查看Element(3)对应的Figureout结果如何。

结果却发现，无论你运行多少次，得到的结果都是”Not found”。也就是说索引Element(3)并不在HashMap中。这怎么可能呢？

原因得慢慢来说：Element的HashCode方法继承自Object，而Object中的HashCode方法返回的HashCode对应于当前的地址，也就是说对于不同的对象，即使它们的内容完全相同，用HashCode（）返回的值也会不同。这样实际上违背了我们的意图。因为我们在使用 HashMap时，希望利用相同内容的对象索引得到相同的目标对象，这就需要HashCode()在此时能够返回相同的值。在上面的例子中，我们期望 new Element(i)(i=5)与 Elementtest=newElement(5)是相同的，而实际上这是两个不同的对象，尽管它们的内容相同，但它们在内存中的地址不同。因此很自然的，上面的程序得不到我们设想的结果。下面对Element类更改如下：

classElement{

intnumber;

publicElement(intn){

number=n;

}

publicinthashCode(){

returnnumber;

}

publicbooleanequals(Objecto){

return(oinstanceofElement)&&(number==((Element)o).number);

}

}

在这里Element覆盖了Object中的hashCode()和equals()方法。覆盖hashCode()使其以number的值作为 hashcode返回，这样对于相同内容的对象来说它们的hashcode也就相同了。而覆盖equals()是为了在HashMap判断两个key是否相等时使结果有意义（有关重写equals()的内容可以参考我的另一篇文章《重新编写Object类中的方法》）。修改后的程序运行结果如下：

h2:

GettheresultforElement:

Impossible!

请记住：如果你想有效的使用HashMap，你就必须重写在其的HashCode()。

还有两条重写HashCode()的原则：

[list=1]

不必对每个不同的对象都产生一个唯一的hashcode，只要你的HashCode方法使get()能够得到put()放进去的内容就可以了。即”不为一原则”。

生成hashcode的算法尽量使hashcode的值分散一些，不要很多hashcode都集中在一个范围内，这样有利于提高HashMap的性能。即”分散原则”。

文章到此结束，如果本次分享的java hashmap继承什么区别和java中Hashtable和HashMap的区别分析的问题解决了您的问题，那么我们由衷的感到高兴！