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<string, string> map = new hashmap<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()) {
object key = iterator.next();
system.out.println("map.get(key) is :" + map.get(key));
}
// 定义hashtable,用来测试
hashtable<string, string> tab = new hashtable<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()) {
object key = iterator_1.next();
system.out.println("tab.get(key) is :" + tab.get(key));
}
treemap<string, string> tmp = new treemap<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()) {
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语言的特性。