treemap.docx

treemap.docx

《treemap.docx》由会员分享，可在线阅读，更多相关《treemap.docx（14页珍藏版）》请在冰豆网上搜索。

treemap

treemap

我们知道HashMap的存储位置是按照key这个对象的hashCode来存放的，而TreeMap则是不是按照hashCode来存放，他是按照实现的Comparable接口的compareTo这个方法来存储的，

只要compareTo的返回结果为0就表示两个对象相等，那么就存不进去两个对象，后put的就把前面的覆盖掉，甚至我们都不用重写equasls和hashCode方法，而

只需要实现Comparable接口来重写comparareTo方法就行了，但是我们不能保证在应用中不会用到HashMap，所以保持良好的习惯，当我们定义了一个对象之后习惯性的

重写equals和hashCode方法。

本文比较详细的解释了TreeMap、Comparable、Comparator这三者的关联。

　　测试Comparable接口：

　　第一次比较：

定义一个User类，实现Comparable接口，按照年龄排序，我们让equals为true，而hashCode也始终相等。

publicclassUserimplementsComparable{

privateStringid;

privateStringname;

privateIntegerage;

publicUser（）{

}

publicUser（Stringid,Stringname,Integerage）{

super（）;

this.id=id;

this.name=name;

this.age=age;

}

publicStringgetId（）{

returnid;

}

publicvoidsetId（Stringid）{

this.id=id;

}

publicStringgetName（）{

returnname;

}

publicvoidsetName（Stringname）{

this.name=name;

}

publicIntegergetAge（）{

returnage;

}

publicvoidsetAge（Integerage）{

this.age=age;

}

@Override

publicStringtoString（）{

return"User[name="+name+",age="+age+"]";

}

@Override

publicbooleanequals（Objectobj）{

returntrue;

}

@Override

publicinthashCode（）{

return0;

}

publicintcompareTo（Usero）{

returnthis.age>o.getAge（）?

1:

this.age==o.getAge（）?

0:

-1;

}

}

　　测试代码：

publicclassTestUser{

publicstaticvoidmain（String[]args）{

MapuserHashMap=newHashMap（）;

Useruser1=newUser（"1","Jay",30）;

Useruser2=newUser（"2","Jolin",21）;

Useruser3=newUser（"3","JackCheng",22）;

Useruser4=newUser（"4","BruceLee",22）;

userHashMap.put（user1,100）;

userHashMap.put（user2,200）;

userHashMap.put（user3,300）;

userHashMap.put（user4,400）;

System.out.println（userHashMap）;

MapuserTreeMap=newTreeMap（）;

userTreeMap.put（user1,100）;

userTreeMap.put（user2,200）;

userTreeMap.put（user3,300）;

userTreeMap.put（user4,400）;

System.out.println（userTreeMap）;

}

}

结果

{User[name=Jay,age=30]=400}

{User[name=Jolin,age=21]=200,User[name=JackCheng,age=22]=400,User[name=Jay,age=30]=100}

1

2

3

　　结论：

对于HashMap而言，只要key的equals相等就表示两个元素相等，HashMap就存不进去；而TreeMap是不管equals和hashCode的，只要compareTo相等就表示两个元素相同，就存不进去。

　　2.第二次比较：

现在我们按照id来重写hashCode和equals方法，如下：

@Override

publicinthashCode（）{

finalintprime=31;

intresult=1;

result=prime*result+（（id==null）?

0:

id.hashCode（））;

returnresult;

}

@Override

publicbooleanequals（Objectobj）{

if（this==obj）

returntrue;

if（obj==null）

returnfalse;

if（getClass（）!

=obj.getClass（））

returnfalse;

Userother=（User）obj;

if（id==null）{

if（other.id!

=null）

returnfalse;

}elseif（!

id.equals（other.id））

returnfalse;

returntrue;

}

测试代码不变，还是上面的测试代码，结果：

{User[name=Jolin,age=21]=200,User[name=Jay,age=30]=100,User[name=BruceLee,age=22]=400,User[name=JackCheng,age=22]=300}

{User[name=Jolin,age=21]=200,User[name=JackCheng,age=22]=400,User[name=Jay,age=30]=100}

1

2

说明：

HashMap只要equals不等那就表示不等，而对于TreeMap如果compareTo相等，那么2个元素就相等，并且排序是按照compareTo方法定义的排序规则。

接下来再在测试代码里面添加List测试：

ListuserList=newArrayList（）;

userList.add（user1）;

userList.add（user2）;

userList.add（user3）;

userList.add（user4）;

System.out.println（userList）;

Collections.sort（userList）;

System.out.println（userList）;

结果：

{User[name=Jolin,age=21]=200,User[name=Jay,age=30]=100,User[name=BruceLee,age=22]=400,User[name=JackCheng,age=22]=300}

{User[name=Jolin,age=21]=200,User[name=JackCheng,age=22]=400,User[name=Jay,age=30]=100}

[User[name=Jay,age=30],User[name=Jolin,age=21],User[name=JackCheng,age=22],User[name=BruceLee,age=22]]

[User[name=Jolin,age=21],User[name=JackCheng,age=22],User[name=BruceLee,age=22],User[name=Jay,age=30]]

当调用sort方法之后List里面的元素就按照age排序了。

对于Comparator，一种叫做策略模式的设计模式，我们在User中实现Comparable接口，重写里面的方法，可以实现对User按age排序，这个排序算法是

存在于User内部的，换句话说User和排序算法是相互依存的，User只能用compareTo这个算法，而compareTo算法也只能为User服务，那么如果我们其他

地方也有同样的需求，就只能再实现一次Comparable，来为另外一个对象服务，这就有点重复的感觉，而且代码没有得到复用，样子对象和算法混在一

起耦合性很强，于是希望把算法和模型分离出来，让算法单独存在，不同的对象可以使用同一个算法，并且二者是分离的，没有混为一体。

当然可以分

开那必然还是可以放在一起的。

用一句比较专业点的话来讲就是策略模式有两个特点：

1.封装变化。

2.变成中使用接口而不实现接口。

如果我再说得直白一点，策略模式就是一种面向接口编程的思想。

这点在多线程里面也有所体现，就是为什么我们在开启新线程的时候要newThread（Runnable接口），

参数传接口而不推荐去继承Thread，虽然也可以继承，这也是体现面向对象的封装特性，将run的算法和线程分离，可以实现run所在类的复用，虽然一般都不会去复用，

当然这里还有一点就是Java只能单继承，如果继承了Thread就不能在继承其他的类。

此时我们的User是按照age排序，那如果想按照名字排序呢，那就没办法了，

但是如果将算法分离出来，需要用名字排序我们就传用名字排序的算法进去，需要用age排序就传age排序算法进去。

环境持有接口引用，通过set方法将接口实现

传入到环境，在环境中来调用接口方法，这完完全全是面向接口的特点。

下面的第一个例子就是存放在一起的，因为TreeMap的构造方法其中就有一个是待Comparator

接口参数的构造方法，该参数只要实现了Comparator接口就行，如下：

publicTreeMap（Comparator

superK>comparator）{

parator=comparator;

}

举例：

有一个Person类，实现了Comparator接口，并且按照岁数排序：

publicclassPersonimplementsComparator{

privateStringid;

privateStringname;

privateIntegerage;

publicPerson（）{

}

publicPerson（Stringid,Stringname,Integerage）{

this.id=id;

this.name=name;

this.age=age;

}

publicStringgetId（）{

returnid;

}

publicvoidsetId（Stringid）{

this.id=id;

}

publicStringgetName（）{

returnname;

}

publicvoidsetName（Stringname）{

this.name=name;

}

publicIntegergetAge（）{

returnage;

}

publicvoidsetAge（Integerage）{

this.age=age;

}

@Override

publicStringtoString（）{

return"Person[name="+name+",age="+age+"]";

}

@Override

publicinthashCode（）{

finalintprime=31;

intresult=1;

result=prime*result+（（id==null）?

0:

id.hashCode（））;

returnresult;

}

@Override

publicbooleanequals（Objectobj）{

if（this==obj）

returntrue;

if（obj==null）

returnfalse;

if（getClass（）!

=obj.getClass（））

returnfalse;

Personother=（Person）obj;

if（id==null）{

if（other.id!

=null）

returnfalse;

}elseif（!

id.equals（other.id））

returnfalse;

returntrue;

}

publicintcompare（Persono1,Persono2）{

returno1.getAge（）>o2.getAge（）?

1:

o1.getAge（）==o2.getAge（）?

0:

-1;

}

}

测试：

publicclassTestPerson{

publicstaticvoidmain（String[]args）{

MappersonHashMap=newHashMap（）;

Personperson1=newPerson（"1","Jay",30）;

Personperson2=newPerson（"2","Jolin",21）;

Personperson3=newPerson（"3","JackCheng",22）;

Personperson4=newPerson（"4","BruceLee",22）;

personHashMap.put（person1,100）;

personHashMap.put（person2,200）;

personHashMap.put（person3,300）;

personHashMap.put（person4,400）;

System.out.println（personHashMap）;

MappersonTreeMap=newTreeMap（newPerson（））;

personTreeMap.put（person1,100）;

personTreeMap.put（person2,200）;

personTreeMap.put（person3,300）;

personTreeMap.put（person4,400）;

System.out.println（personTreeMap）;

}

}

结果：

{Person[name=Jolin,age=21]=200,Person[name=Jay,age=30]=100,Person[name=BruceLee,age=22]=400,Person[name=JackCheng,age=22]=300}

{Person[name=Jolin,age=21]=200,Person[name=JackCheng,age=22]=400,Person[name=Jay,age=30]=100}

1

2

依然是compara方法相等的元素表示相同，只能存放一个进去，并且是按照age排序的。

在List中的结果：

publicclassTestPerson{

publicstaticvoidmain（String[]args）{

MappersonHashMap=newHashMap（）;

Personperson1=newPerson（"1","Jay",30）;

Personperson2=newPerson（"2","Jolin",21）;

Personperson3=newPerson（"3","JackCheng",22）;

Personperson4=newPerson（"4","BruceLee",22）;

personHashMap.put（person1,100）;

personHashMap.put（person2,200）;

personHashMap.put（person3,300）;

personHashMap.put（person4,400）;

System.out.println（personHashMap）;

MappersonTreeMap=newTreeMap（newPerson（））;

personTreeMap.put（person1,100）;

personTreeMap.put（person2,200）;

personTreeMap.put（person3,300）;

personTreeMap.put（person4,400）;

System.out.println（personTreeMap）;

ListpersonList=newArrayList（）;

personList.add（person1）;

personList.add（person2）;

personList.add（person3）;

personList.add（person4）;

System.out.println（personList）;

Collections.sort（personList,newPerson（））;

System.out.println（personList）;

}

}

结果：

{Person[name=Jolin,age=21]=200,Person[name=Jay,age=30]=100,Person[name=BruceLee,age=22]=400,Person[name=JackCheng,age=22]=300}

{Person[name=Jolin,age=21]=200,Person[name=JackCheng,age=22]=400,Person[name=Jay,age=30]=100}

[Person[name=Jay,age=30],Person[name=Jolin,age=21],Person[name=JackCheng,age=22],Person[name=BruceLee,age=22]]

[Person[name=Jolin,age=21],Person[name=JackCheng,age=22],Person[name=BruceLee,age=22],Person[name=Jay,age=30]]

调用sort方法前没排序，而调用之后按照age排序了。

其实将算法和模型分离也非常类似，只需要将实现Comparator接口的类单独拿出去就ok了。

现在定义Person类，不实现Comparator接口，而将SortPerson类来

实现该接口，其实就是用SortPerson类代替之前TreeMap中的参数，之前的参数是实现了Comparator接口的Person对象。

Person类：

publicclassPerson{

privateStringid;

privateStringname;

privateIntegerage;

publicPerson（）{

}

publicPerson（Stringid,Stringname,Integerage）{

this.id=id;

this.name=name;

this.age=age;

}

publicStringgetId（）{

returnid;

}

publicvoidsetId（Stringid）{

this.id=id;

}

publicStringgetName（）{

returnname;

}

publicvoidsetName（Stringname）{

this.name=name;

}

publicIntegergetAge（）{

returnage;

}

publicvoidsetAge（Integerage）{

this.age=age;

}

@Override

publicStringtoString（）{

return"Person[name="+name+",age="+age+"]";

}

@Override

publicinthashCode（）{

finalintprime=31;

intresult=1;

result=prime*result+（（id==null）?

0:

id.hashCode（））;

returnresult;

}

@Override

publicbooleanequals（Objectobj）{

if（this==obj）

returntrue;

if（ob