使用背景

  • Java中的对象，正常情况下，只能进行比较：== 或 != 。不能使用 > 或 < 的
  • 但是在开发场景中，我们需要对多个对象进行排序，言外之意，就需要比较对象的大小。
  • 如何实现？使用两个接口中的任何一个：Comparable 或 Comparator

自然排序：java.lang.Comparable

  • 实现 Comparable 的类必须实现 compareTo(Object obj) 方法，两个对象即通过 compareTo(Object obj) 方法的返回值来比较大小。
    • 如果当前对象this大于形参对象obj，则返回正整数
    • 如果当前对象this小于形参对象obj，则返回负整数
    • 如果当前对象this等于形参对象obj，则返回零。
  • 实现Comparable接口的对象列表（和数组）可以通过 Collections.sort 或 Arrays.sort进行自动排序。实现此接口的对象可以用作有序映射中的键或有序集合中的元素，无需指定比较器。
  • 对于类 C 的每一个e1和e2来说，当且仅当 e1.compareTo(e2) == 0 与 e1.equals(e2) 具有相同的 boolean 值时，类 C 的自然排序才叫做与 equals 一致。建议（虽然不是必需的）最好使自然排序与 equals 一致。
  • Comparable 的典型实现：(默认都是从小到大排列的)

String：按照字符串中字符的Unicode值进行比较
Character：按照字符的Unicode值来进行比较
数值类型对应的包装类以及BigInteger、BigDecimal：按照它们对应的数值大小进行比较 

  1.  public static void main(String[] args) {
  2.         Person[] people = new Person[5];
  3.         people[0] = new Person("Tom", 15);
  4.         people[1] = new Person("Bob", 32);
  5.         people[2] = new Person("Tom", 56);
  6.         people[3] = new Person("Gall", 23);
  7.         people[4] = new Person("Silly", 66);
  8.         Arrays.sort(people);
  9.         System.out.println(Arrays.toString(people));
  11.     }
  12. }
  15. class Person implements Comparable{
  17.     String name;
  18.     int age;
  20.     public Person(String name, int age) {
  21.         this.name = name;
  22.         this.age = age;
  23.     }
  25.     @Override
  26.     public int compareTo(Object o) {
  27.         if(o instanceof Person){
  28.             Person p = (Person)o;
  29.             if(this.name.equals(p.name)){
  30.                 return Integer.compare(this.age,p.age);
  31.             }else{
  32.                 return this.name.compareTo(p.name);
  33.             }
  34.         }
  35.        throw new RuntimeException("类型不匹配");
  36.     }
  38.     @Override
  39.     public String toString() {
  40.         return "Person{" +
  41.                 "name='" + name + '\'' +
  42.                 ", age=" + age +
  43.                 '}';
  44.     }

定制排序java.util.Comparator

  • 当元素的类型没有实现java.lang.Comparable接口而又不方便修改代码， 或者实现了java.lang.Comparable接口的排序规则不适合当前的操作，那么可以考虑使用 Comparator类的对象来排序，强行对多个对象进行整体排序的比较。
  • 重写compare(Object o1,Object o2)方法，比较o1和o2的大小：
    • 如果方法返回正整数，则表示o1大于o2；
    • 如果返回0，表示相等；
    • 返回负整数，表示 o1小于o2。
  • 可以将 Comparator的对象传递给 sort 方法（如 Collections.sort 或 Arrays.sort）， 从而允许在排序顺序上实现精确控制。

Arrays.sort(goods,com);
Collections.sort(coll,com);
new TreeSet(com);

  1. //指明比较大小的方式:照名称从低到高排序,再照年龄从高到低排序
  2.         Person[] p = new Person[5];
  3.         p[0] = new Person("Dom", 15);
  4.         p[1] = new Person("Bob", 32);
  5.         p[2] = new Person("Dom", 56);
  6.         p[3] = new Person("Ali", 23);
  7.         p[4] = new Person("Silly", 66);
  8.         Arrays.sort(p, new Comparator() {
  9.             @Override
  10.             public int compare(Object o1, Object o2) {
  11.                 if(o1 instanceof Person && o2 instanceof Person){
  12.                     Person p1 = (Person) o1;
  13.                     Person p2 = (Person) o2;
  14.                     if(p1.name.equals(p2.name)){
  15.                         return -Integer.compare(p1.age,p2.age);
  16.                     }else {
  17.                         return p1.name.compareTo(p2.name);
  18.                     }
  19.                 }
  20.                 throw new RuntimeException("类型不匹配");
  21.             }
  22.         });
  23.         System.out.println(Arrays.toString(p));
  24.     }

两种排序方式对比

Comparable接口的方式一旦一定，保证Comparable接口实现类的对象在任何位置都可以比较大小。
Comparator接口属于临时性的比较。