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));      
      }      
  }