Comparable & Comparator

Comparable (Java 2 Platform SE 6)

public interface Comparable<T>

java.lang (Java 2 Platform SE 6)java.lang.Comparable

此接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序

，类的 compareTo

方法被称为它的自然比较方法

。

Comparator (Java 2 Platform SE 6)

public interface Comparator<T>          

java.util (Java 2 Platform SE 6)java.util.Comparator

强行对某个对象 collection 进行整体排序

的比较函数。

java.util.Collections

Collections (Java 2 Platform SE 6)

public static <T extends Comparable
<? super T>> void sort
(List
<T> list)

根据元素的自然顺序
对指定列表按升序进行排序。列表中的所有元素都必须实现 Comparable
接口

导读：

　　关于引用数据类型的排序（自然排序和客户化排序）：

　　1.对象本身实现Comparable接口,那么该类的实例就是可以排序的（实现其comparTo()方法）.

　　只要实现了Comparable接口,就可以调用Collections的sort方法对集合中的元素排序.

　　2.实现Comparator接口的一个实例也可以实现排序功能.

　　看一下Comparator的全部内容:

　　public
interface Comparator {

　　int compare(Object o1, Object o2);

　　boolean
equals(Object obj);

　　}

　　定义了两个方法,我们一般都只需要实现compare方法。

　　为什么呢？

　　因为所有自定义类默认extends Object,而Object中已经将equals()实现

　　Comparator一般都作为一个匿名类出现,对于没有实现Comparable的对象的集合,排序的时候

　　需要指定一个Comparator.

　　这里举例说明

　　对于实现了Comparable的类（自然排序）我们就用最简单的Integer

　　List list=new ArrayList();

　　list.add(new Integer(3));

　　list.add(new Integer(53));

　　list.add(new Integer(34));

　　Collections.sort(list);

　　对于没有实现Comparable的,我们就用Object,按照hashCode大小来排序.

　　List list= new
ArrayList();

　　list.add(new Object());

　　list.add(new Object());

　　list.add(new Object());

　　Collections.sort(list,new Comparator(){
public int compare(Object o1, Object o2){

　　return
(o1.hashCode()-o2.hashCode());

　　})

　　这里定义了一个排序规则，以匿名类的形式出现，当然你也可以定义一个自定义的类实现Comparator，

　　这样这个“排序规则”就能得以保存。

　　那Comparable 和 Comparator 接口有什么区别呢？

　　“白话文”的解释：用自定义类实现Comparable接口，那么这个类就具有排序功能，Comparable和具体你要进行排序的类的实例邦定。而Comparator比较灵活，它没有和任何类绑定，实现它的自定义类仅仅定义了一种排序方式或排序规则。不言而喻，这种方式比较灵活。我们的要排序的类可以分别和多个实现Comparator接口的类绑定，从而达到可以按自己的意愿实现按多种方式排序的目的。Comparable——“静态绑定排序”,Comparator——“动态绑定排序”。

　　Trackback: http://tb.blog.csdn.net/TrackBack.aspx?PostId=1784584
　　[收藏到我的网摘] [发送Trackback] bojianyu发表于 2007年09月14日 08:58:00

本文转自

http://blog.csdn.net/bojianyu/archive/2007/09/14/1784584.aspx

Comparable & Comparator
都是用来实现集合中的排序的，只是Comparable是在集合内部定义的方法实现的排序，Comparator是在集合外部实现的排序，所以，如想实现排序，就需要在集合外定义Comparator接口的方法
或 在集合内实现Comparable接口的方法。

具体请看 <Thinking in java>

Comparable是一个对象本身就已经支持自比较所需要实现的接口（如String Integer自己就可以完成比较大小操作）

而Comparator是一个专用的比较器，当这个对象不支持自比较或者自比较函数不能满足你的要求时，你可以写一个比较器来完成两个对象之间大小的比较。

可以说一个是自已完成比较，一个是外部程序实现比较的差别而已。

用Comparator是策略模式（strategy
design pattern），就是不改变对象自身，而用一个策略对象（strategy object）来改变它的行为。

比如：你想对整数采用绝对值大小来排序，Integer是不符合要求的，你不需要去修改Integer类（实际上你也不能这么做）去改变它的排序行为，只要使用一个实现了Comparator接口的对象来实现控制它的排序就行了。

java 代码

//AbsComparator.java

import java.util.*;

public class AbsComparator implements Comparator {

public int compare(Object o1, Object o2) {

int v1 = Math.abs(((Integer)o1).intValue());

int v2 = Math.abs(((Integer)o2).intValue());

return v1 > v2 ? 1 : (v1 == v2 ? 0 :
-1);

}

}

可以用下面这个类测试AbsComparator：

//Test.java

import java.util.*;

public class Test {

public static void main(String[] args) {

//产生一个20个随机整数的数组（有正有负）

Random rnd =
new Random();

Integer[] integers = new
Integer[20];

for(int i = 0; i <
integers.length; i++)

integers[i] = new
Integer(rnd.nextInt(100) * (rnd.nextBoolean() ? 1 : -1));

System.out.println("用Integer内置方法排序：");

Arrays.sort(integers);

System.out.println(Arrays.asList(integers));

System.out.println("用AbsComparator排序：");

Arrays.sort(integers, new AbsComparator());

System.out.println(Arrays.asList(integers));

}

}