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。

import java.util.hashmap;  import java.util.hashtable;  import java.util.iterator;  import java.util.map;  import java.util.treemap;  public class hashmaps {  public static void main(string[] args) {  map map = new hashmap();  map.put("a", "aaa");  map.put("b", "bbb");  map.put("c", "ccc");  map.put("d", "ddd");  iterator iterator = map.keyset().iterator();  while (iterator.hasnext()) {  object key = iterator.next();  system.out.println("map.get(key) is :"   map.get(key));  }  // 定义hashtable,用来测试  hashtable tab = new hashtable();  tab.put("a", "aaa");  tab.put("b", "bbb");  tab.put("c", "ccc");  tab.put("d", "ddd");  iterator iterator_1 = tab.keyset().iterator();  while (iterator_1.hasnext()) {  object key = iterator_1.next();  system.out.println("tab.get(key) is :"   tab.get(key));  }  treemap tmp = new treemap();  tmp.put("a", "aaa");  tmp.put("b", "bbb");  tmp.put("c", "ccc");  tmp.put("d", "cdc");  iterator iterator_2 = tmp.keyset().iterator();  while (iterator_2.hasnext()) {  object key = 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:

import java.util.*;  public class exp1 {  public static void main(string[] args){  hashmap h1=new hashmap();  random r1=new random();  for (int i=0;i<1000;i  ){  integer t=new integer(r1.nextint(20));  if (h1.containskey(t))  ((ctime)h1.get(t)).count  ;  else  h1.put(t, new ctime());  }  system.out.println(h1);  }  }  class ctime{  int count=1;  public string tostring(){  return integer.tostring(count);  }  }

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

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

import java.util.*;  public class exp2 {  public static void main(string[] args){  hashmap h2=new hashmap();  for (int i=0;i<10;i  )  h2.put(new element(i), new figureout());  system.out.println("h2:");  system.out.println("get the result for element:");  element test=new element(5);  if (h2.containskey(test))  system.out.println((figureout)h2.get(test));  else  system.out.println("not found");  }  }  class element{  int number;  public element(int n){  number=n;  }  }  class figureout{  random r=new random();  boolean possible=r.nextdouble()>0.5;  public string tostring(){  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类更改如下：

class element{  int number;  public element(int n){  number=n;  }  public int hashcode(){  return number;  }  public boolean equals(object o){  return (o instanceof element) && (number==((element)o).number);  }  }

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

h2:

get the result for element:

impossible!

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

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

[list=1]

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

生成hashcode的算法尽量使hashcode的值分散一些，不要很多hashcode都集中在一个范围内，这样有利于提高hashmap的性能。即”分散原则”。至于第二条原则的具体原因，有兴趣者可以参考bruce eckel的《thinking in java》，在那里有对hashmap内部实现原理的介绍，这里就不赘述了。

掌握了这两条原则，你就能够用好hashmap编写自己的程序了。不知道大家注意没有，java.lang.object中提供的三个方法：clone()，equals()和hashcode()虽然很典型，但在很多情况下都不能够适用，它们只是简单的由对象的地址得出结果。这就需要我们在自己的程序中重写它们，其实java类库中也重写了千千万万个这样的方法。利用面向对象的多态性——覆盖，java的设计者很优雅的构建了java的结构，也更加体现了java是一门纯oop语言的特性。