今天博主在翻阅TreeMap的源码,发现其键必须是实现Comparable或者Comparator的接口时产生了一些兴趣,比如在TreeMap中的put方法分别对Comparable和Comparator接口分别进行处理。那么疑问就来了,Comparable和Comparator接口的区别是什么,Java中为什么会存在两个类似的接口?
Comparable和Comparator接口都是用来比较大小的,首先来看一下Comparable的定义:
1
2
3
4
5
|
package
java.lang;
import
java.util.*;
public
interface
Comparable<T> {
public
int
compareTo(T o);
}
|
Comparator的定义如下:
1
2
3
4
5
|
package
java.util;
public
interface
Comparator<T> {
int
compare(T o1, T o2);
boolean
equals(Object obj);
}
|
Comparable对实现它的每个类的对象进行整体排序。这个接口需要类本身去实现(这句话没看懂?没关系,接下来看个例子就明白了)。若一个类实现了Comparable 接口,实现 Comparable 接口的类的对象的 List 列表 ( 或数组)可以通过 Collections.sort(或 Arrays.sort)进行排序。此外,实现 Comparable 接口的类的对象 可以用作 “有序映射 ( 如 TreeMap)” 中的键或 “有序集合 (TreeSet)” 中的元素,而不需要指定比较器。
举例(类Person1实现了Comparable接口)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
package
collections;
public
class
Person1
implements
Comparable<Person1>
{
private
int
age;
private
String name;
public
Person1(String name,
int
age)
{
this
.name = name;
this
.age = age;
}
@Override
public
int
compareTo(Person1 o)
{
return
this
.age-o.age;
}
@Override
public
String toString()
{
return
name+
":"
+age;
}
}
|
可以看到Person1实现了Comparable接口中的compareTo方法。实现Comparable接口必须修改自身的类,即在自身类中实现接口中相应的方法。
测试代码:
1
2
3
4
5
6
7
8
9
10
11
12
|
Person1 person1 =
new
Person1(
"zzh"
,
18
);
Person1 person2 =
new
Person1(
"jj"
,
17
);
Person1 person3 =
new
Person1(
"qq"
,
19
);
List<Person1> list =
new
ArrayList<>();
list.add(person1);
list.add(person2);
list.add(person3);
System.out.println(list);
Collections.sort(list);
System.out.println(list);
|
输出结果:
1
2
|
[zzh:
18
, jj:
17
, qq:
19
]
[jj:
17
, zzh:
18
, qq:
19
]
|
如果我们的这个类无法修改,譬如String,我们又要兑取进行排序,当然String中已经实现了Comparable接口,如果单纯的用String举例就不太形象。对类自身无法修改这就用到了Comparator这个接口(策略模式)。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
|
public
final
class
Person2
{
private
int
age;
private
String name;
public
Person2(String name,
int
age)
{
this
.name = name;
this
.age = age;
}
@Override
public
String toString()
{
return
name+
":"
+age;
}
//getter and setter方法省略....
}
|
如类Person2,这个类已经固定,无法进行对其类自身的修改,也修饰词final了,你也别想继承再implements Comparable,那么此时怎么办呢?在类的外部使用Comparator的接口。如下测试代码:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
Person2 p1 =
new
Person2(
"zzh"
,
18
);
Person2 p2 =
new
Person2(
"jj"
,
17
);
Person2 p3 =
new
Person2(
"qq"
,
19
);
List<Person2> list2 =
new
ArrayList<Person2>();
list2.add(p1);
list2.add(p2);
list2.add(p3);
System.out.println(list2);
Collections.sort(list2,
new
Comparator<Person2>(){
@Override
public
int
compare(Person2 o1, Person2 o2)
{
if
(o1 ==
null
|| o2 ==
null
)
return
0
;
return
o1.getAge()-o2.getAge();
}
});
System.out.println(list2);
|
输出结果:
1
2
|
[zzh:
18
, jj:
17
, qq:
19
]
[jj:
17
, zzh:
18
, qq:
19
]
|
这里(public static <T> void sort(List<T> list, Comparator<? super T> c) )采用了内部类的实现方式,实现compare方法,对类Person2的list进行排序。
再譬如博主遇到的真实案例中,需要对String进行排序,且不区分大小写,我们知道String中的排序是字典排序,譬如:A a D排序之后为A D a,这样显然不对,那么该怎么办呢?同上(下面代码中的list是一个String的List集合):
1
2
3
4
5
6
7
8
9
10
|
Collections.sort(list,
new
Comparator<String>()
{
@Override
public
int
compare(String o1, String o2)
{
if
(o1 ==
null
|| o2 ==
null
)
return
0
;
return
o1.toUpperCase().compareTo(o2.toUpperCase());
}
});
|
这样就可以实现不区分大小进行排序String的集合了,是不是很方便~
细心的同学可能会有疑问,明明在Comparator接口中定义了两个方法,为什么继承的时候只实现了一个方法,难道要颠覆我对Java接口常识的理解了嚒?
实际上,我们知道当一个类没有显式继承父类的时候,会有一个默认的父类,即java.lang.Object,在Object类中有一个方法即为equals方法,所以这里并不强制要求实现Comparator接口的类要实现equals方法,直接调用父类的即可,虽然你显式的实现了equals()方法 will be a better choice~
在《Effective Java》一书中,作者Joshua Bloch推荐大家在编写自定义类的时候尽可能的考虑实现一下Comparable接口,一旦实现了Comparable接口,它就可以跟许多泛型算法以及依赖于改接口的集合实现进行协作。你付出很小的努力就可以获得非常强大的功能。
事实上,Java平台类库中的所有值类都实现了Comparable接口。如果你正在编写一个值类,它具有非常明显的内在排序关系,比如按字母顺序、按数值顺序或者按年代顺序,那你就应该坚决考虑实现这个接口。
compareTo方法不但允许进行简单的等同性进行比较,而且语序执行顺序比较,除此之外,它与Object的equals方法具有相似的特征,它还是一个泛型。类实现了Comparable接口,就表明它的实例具有内在的排序关系,为实现Comparable接口的对象数组进行排序就这么简单: Arrays.sort(a);
对存储在集合中的Comparable对象进行搜索、计算极限值以及自动维护也同样简单。列如,下面的程序依赖于String实现了Comparable接口,它去掉了命令行参数列表中的重复参数,并按字母顺序打印出来:
1
2
3
4
5
6
7
|
public
class
WordList{
public
static
void
main(String args[]){
Set<String> s =
new
TreeSet<String>();
Collections.addAll(s,args);
System.out.println(s);
}
}
|
Comparable 是排序接口;若一个类实现了 Comparable 接口,就意味着 “该类支持排序”。而 Comparator 是比较器;我们若需要控制某个类的次序,可以建立一个 “该类的比较器” 来进行排序。
前者应该比较固定,和一个具体类相绑定,而后者比较灵活,它可以被用于各个需要比较功能的类使用。可以说前者属于 “静态绑定”,而后者可以 “动态绑定”。
我们不难发现:Comparable 相当于 “内部比较器”,而 Comparator 相当于 “外部比较器”。
原文出处: 朱小厮
from: http://www.importnew.com/19250.html