java中的Comparator和Comparable比较器的用法

Comparable和Comparator都是用来实现集合中的排序的，Comparator位于包java.util下，而Comparable位于包java.lang下，Comparable是一个对象本身就已经支持自比较所需要实现的接口（如 String、Integer 自己就可以完成比较大小操作），是内部定义的排序；而后者在一个独立的类中实现比较，是外部实现的排序。 如果一个类没有实现Comparable接口，或是这个对象不支持自比较或者自比较函数不能满足你的要求时，可以通过Comparator来实现比较算法进行排序，并且为了使用不同的排序标准做准备，比如：升序、降序。所以，如想实现排序，就需要让类对象自身实现Comparable接口，重写其中的compareTo(T o)方法；或在外部定义比较器实现Comparator接口，重写其compare(T o1,T o2)方法。前者只有一个参数，后者有两个参数。排序时可以调用java.util.Arrays.sort()来排序对象数组，或是调用集合中的sort()方法就可以按照相应的排序方法进行排序。方法返回一个基本类型的整型，返回负数表示o1小于o2，返回0表示o1和o2相等，返回正数表示o1大于o2。 

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

Comparable

public interface Comparable<T>

1.Comparable接口对实现它的每个类的对象强加一个整体排序。 这个排序被称为类的自然排序 ，类的compareTo方法被称为其自然比较方法。该接口有且只有一个方法int compareTo(T o)所以继承此接口需要实现该方法。compareTo返回值-1、0、1。 
2.Collections.sort （和Arrays.sort ）可以自动对实现此接口的对象进行列表（和数组）排序。 实现该接口的对象，可以使用如在键sorted map或作为在元件sorted set ，而不需要指定一个comparator 。

Comparator

public interface Comparator<T>

1.比较功能，对一些对象的集合施加了一个整体排序 。 可以将比较器传递给排序方法（如Collections.sort或Arrays.sort ），以便对排序顺序进行精确控制。 比较器还可以用来控制某些数据结构（如顺序sorted sets或sorted maps ），或对于不具有对象的集合提供的排序natural ordering 。 
2.通过比较c上的一组元素S的确定的顺序对被认为是与equals一致当且仅当c.compare(e1, e2)==0具有用于S每e1和e2相同布尔值e1.equals(e2)。 
3.一般是在比较器例如: Collections.sort(List<T> list, Comparator<? super T> c) ，Arrays.sort(T[] a, Comparator<? super T> c)根据指定的比较器引起的顺序对指定的列表进行排序。 在Comparator比较器中重写int compare(T o1, T o2) 如果遇到数字的比较，直接在方法内返回两个对象的属性的差值，例如o1.getValue()-o2.getValue() 是升序，o2.getValue()-o1.getValue() 是降序；如果遇到字符形式的比较利用compareTo(T o) 方法进行比较，该方法比较从头开始每一个字符，当前者大于后者返回1，当前者小于后者返回-1。

例子：

[java]  view plain  copy

1. import java.util.Arrays;  
2. import java.util.Comparator;  
3. class Person implements Comparable<Person>{  
4.     private String name;  
5.     private int age;  
6.     public Person(String name, int age) {  
7.         this.name = name;  
8.         this.age = age;  
9.     }  
10.     public String getName() {  
11.         return this.name;  
12.     }  
13.     public int getAge() {  
14.         return this.age;  
15.     }  
16.     @Override  
17.     public String toString() {  
18.         return ""+this.name+" "+this.age;  
19.     }  
20.     @Override  
21.     public int compareTo(Person o) {  
22.           //返回值是正数，就是升序排序        //返回值是负数，就是降序排序  
23.         if (this.getName().compareTo(o.getName()) != 0)  
24.             return this.getName().compareTo(o.getName());  
25.         else {  
26.             if (this.getAge() < o.getAge())  
27.                 return -1;  
28.             else if (this.getAge() > o.getAge())  
29.                 return 1;  
30.             else return 0;  
31.         }  
32.     }  
33. }  
34. class Cmp implements Comparator {  
35.     @Override  
36.     public int compare(Object arg0, Object arg1) {  
37.         Person a = (Person) arg0;  
38.         Person b = (Person) arg1;  
39.         if (a.getName().compareTo(b.getName()) != 0)  
40.             return a.getName().compareTo(b.getName());  
41.         else {  
42.             if (a.getAge() < b.getAge())  
43.                 return -1;  
44.             else if (a.getAge() > b.getAge())  
45.                 return 1;  
46.             else return 0;  
47.         }  
48.     }  
49. }  
50. public class Main {  
51.     public static void main(String[] args) {  
52.         Person[] p = new Person[4];  
53.         p[0] = new Person("ZZZ",19);  
54.         p[1] = new Person("AAA", 109);  
55.         p[2] = new Person("AAA", 19);  
56.         p[3] = new Person("YYY",100);  
57. //      Arrays.sort(p);//调用自有的排序  
58.         Arrays.sort(p, new Cmp());//调用Comparator定义的排序  
59.         System.out.println(Arrays.toString(p));  
60.     }  
61. }  

import java.util.*;
import java.lang.Comparable;
 
/**
 * @desc "Comparator"和“Comparable”的比较程序。
 *  (01) "Comparable"
 *  它是一个排序接口，只包含一个函数compareTo()。
 *  一个类实现了Comparable接口，就意味着“该类本身支持排序”，它可以直接通过Arrays.sort() 或 Collections.sort()进行排序。
 *  (02) "Comparator"
 *  它是一个比较器接口，包括两个函数：compare() 和 equals()。
 *  一个类实现了Comparator接口，那么它就是一个“比较器”。其它的类，可以根据该比较器去排序。
 *
 *  综上所述：Comparable是内部比较器，而Comparator是外部比较器。
 *  一个类本身实现了Comparable比较器，就意味着它本身支持排序；若它本身没实现Comparable，也可以通过外部比较器Comparator进行排序。
 */
public class CompareComparatorAndComparableTest{
 
  public static void main(String[] args) {
    // 新建ArrayList(动态数组)
    ArrayList<Person> list = new ArrayList<Person>();
    // 添加对象到ArrayList中
    list.add(new Person("ccc", 20));
    list.add(new Person("AAA", 30));
    list.add(new Person("bbb", 10));
    list.add(new Person("ddd", 40));
 
    // 打印list的原始序列
    System.out.printf("Original sort, list:%s\n", list);
 
    // 对list进行排序
    // 这里会根据“Person实现的Comparable<String>接口”进行排序，即会根据“name”进行排序
    Collections.sort(list);
    System.out.printf("Name   sort, list:%s\n", list);
 
    // 通过“比较器(AscAgeComparator)”，对list进行排序
    // AscAgeComparator的排序方式是：根据“age”的升序排序
    Collections.sort(list, new AscAgeComparator());
    System.out.printf("Asc(age) sort, list:%s\n", list);
 
    // 通过“比较器(DescAgeComparator)”，对list进行排序
    // DescAgeComparator的排序方式是：根据“age”的降序排序
    Collections.sort(list, new DescAgeComparator());
    System.out.printf("Desc(age) sort, list:%s\n", list);
 
    // 判断两个person是否相等
    testEquals();
  }
 
  /**
   * @desc 测试两个Person比较是否相等。
   *  由于Person实现了equals()函数：若两person的age、name都相等，则认为这两个person相等。
   *  所以，这里的p1和p2相等。
   *
   *  TODO：若去掉Person中的equals()函数，则p1不等于p2
   */
  private static void testEquals() {
    Person p1 = new Person("eee", 100);
    Person p2 = new Person("eee", 100);
    if (p1.equals(p2)) {
      System.out.printf("%s EQUAL %s\n", p1, p2);
    } else {
      System.out.printf("%s NOT EQUAL %s\n", p1, p2);
    }
  }
 
  /**
   * @desc Person类。
   *    Person实现了Comparable接口，这意味着Person本身支持排序
   */
  private static class Person implements Comparable<Person>{
    int age;
    String name;
 
    public Person(String name, int age) {
      this.name = name;
      this.age = age;
    }
 
    public String getName() {
      return name;
    }
 
    public int getAge() {
      return age;
    }
 
    public String toString() {
      return name + " - " +age;
    }
 
    /**
     * 比较两个Person是否相等：若它们的name和age都相等，则认为它们相等
     */
    boolean equals(Person person) {
      if (this.age == person.age && this.name == person.name)
        return true;
      return false;
    }
 
    /**
     * @desc 实现 “Comparable<String>” 的接口，即重写compareTo<T t>函数。
     * 这里是通过“person的名字”进行比较的
     */
    @Override
    public int compareTo(Person person) {
      return name.compareTo(person.name);
      //return this.name - person.name;
    }
  }
 
  /**
   * @desc AscAgeComparator比较器
   *    它是“Person的age的升序比较器”
   */
  private static class AscAgeComparator implements Comparator<Person> {
 
    @Override
    public int compare(Person p1, Person p2) {
      return p1.getAge() - p2.getAge();
    }
  }
 
  /**
   * @desc DescAgeComparator比较器
   *    它是“Person的age的 降序比较器”
   */
  private static class DescAgeComparator implements Comparator<Person> {
 
    @Override
    public int compare(Person p1, Person p2) {
      return p2.getAge() - p1.getAge();
    }
  }
}