1.接口Comparable<T> API

   参数类型：T ---可以与此对象进行比较的那些对象的类型

      此接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的compareTo()方法被称为它的自然比较方法。

      实现此接口的对象列表（和数组）可以通过 Collections.sort（和 Arrays.sort）进行自动排序。实现此接口的对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器。

     Comparable也只有int compareTo(T object)一个方法。比较此对象与指定对象的顺序。如果该对象小于、等于或大于指定对象，则分别返回负整数、零或正整数。

1 public class Person implements Comparable
      
         2 {  3     String name;  4     int age;  5     public Person(String name, int age)  6     {  7         super();  8         this.name = name;  9         this.age = age; 10     } 11     public String getName() 12     { 13         return name; 14     } 15     public int getAge() 16     { 17         return age; 18     } 19     @Override 20     public int compareTo(Person p) 21     { 22         return this.age-p.getAge(); 23     } 24     public static void main(String[] args) 25     { 26         Person[] people=new Person[]{
    new Person("wangwu", 18),new Person("zhaoliu", 19)}; 27         System.out.println("排序前"); 28         for (Person person : people) 29         { 30             System.out.print(person.getName()+":"+person.getAge()); 31         } 32         Arrays.sort(people);  33         System.out.println("\n排序后");
      

34         for (Person person : people) 35         { 36             System.out.print(person.getName()+":"+person.getAge()); 37         } 38     } 39 }

2.接口 Comparator<T> API

    强行对某个对象 collection 进行整体排序 的比较函数。可以将 Comparator 传递给 sort 方法（如 Collections.sort 或 Arrays.sort），从而允许在排序顺序上实现精确控制。还可以使用 Comparator 来控制某些数据结构（如有序 set或有序映射）的顺序，或者为那些没有自然顺序的对象 collection 提供排序。

(1)int compare(T o1, T o2)

    比较用来排序的两个参数。根据第一个参数小于、等于或大于第二个参数分别返回负整数、零或正整数。

    抛出异常：ClassCastException - 如果参数的类型不允许此 Comparator 对它们进行比较。

(2)boolean equals(Object obj)

    指示某个其他对象是否“等于”此 Comparator。此方法必须遵守 Object.equals(Object) 的常规协定。此外，仅当 指定的对象也是一个 Comparator，并且强行实施与此 Comparator 相同的排序时，此方法才返回 true。因此，comp1.equals(comp2) 意味着对于每个对象引用 o1 和 o2 而言，都存在 sgn(comp1.compare(o1, o2))==sgn(comp2.compare(o1, o2))。

   注意，不 重写 Object.equals(Object) 方法总是 安全的。然而，在某些情况下，重写此方法可以允许程序确定两个不同的 Comparator 是否强行实施了相同的排序，从而提高性能。

  若一个类要实现Comparator 接口：它一定要实现compare(T o1, T o2) 函数，但可以不实现 equals(Object obj) 函数。

1 //定义一个比较器  2 public class PersonCompartor implements Comparator
      
         3 {  4     @Override  5     public int compare(Person o1, Person o2)  6     {  7         return o1.getAge()-o2.getAge();  8     }  9 } 10  11 public class Person 12 { 13     String name; 14     int age; 15     public Person(String name, int age) 16     { 17         super(); 18         this.name = name; 19         this.age = age; 20     } 21     public String getName() 22     { 23         return name; 24     } 25     public int getAge() 26     { 27         return age; 28     } 29     public static void main(String[] args) 30     { 31         Person[] people=new Person[]{
    new Person("xujian", 20),new Person("xiewei", 10)}; 32         System.out.println("排序前"); 33         for (Person person : people) 34         { 35             System.out.print(person.getName()+":"+person.getAge()); 36         }             //创建比较器参数PersonCompartor
      

37         Arrays.sort(people,new PersonCompartor());  38         System.out.println("\n排序后");

39         for (Person person : people) 40         { 41             System.out.print(person.getName()+":"+person.getAge()); 42         } 43     } 44 }

 

3.Comparator与Comparable比较

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

    Comparable是 定义在 Person类的内部称为“内部排序”，是一种简单的方式，需要修改源代码。

Arrays.sort(people);

(2)Comparator 是比较器，排序时，需要新建比较器对象，将比较器和对象一起传递过去就可以比大小，可称为“外部排序”。

Comparator 是定义在Person的外部的, 此时我们的Person类的结构不需要有任何变化。并且在Comparator 里面用户可以自己实现复杂的可以通用的逻辑,使其可以匹配一些比较简单的对象,那样就可以节省很多重复劳动了。

Arrays.sort(people,new PersonCompartor());