Java中Comparable和Comparator比较

Posted 2020-10-09 三月烟雨飘摇的南方

1、Comparable 介绍

Comparable 是一个排序接口，如果一个类实现了该接口，说明该类本身是可以进行排序的。注意，除了基本数据类型（八大基本数据类型） 的数组或是List，其余类型的对象，Collections.sort或Arrays.sort 是不支持直接进行排序的，因为对象本身是没有“顺序”的，除非你实现了Comparable 接口或是自定义了Comparable 对象，指定了排序规则，才可以进行排序。

Comparable  源码就一个方法,

1 public interface Comparable<T> {
2     public int compareTo(T o);
3 }

泛型T表示要进行比较的对象所属的类型，compareTo 比较对象之间的值的大小关系，如果该对象小于、等于或大于指定对象，则分别返回负整数、零或正整数。

定义一个对象：

 1 public class Person implements Comparable<Person>{
 2   public int age;
 3   
 4   public Person(int age){
 5     this.age = age;
 6   }
 7   public String toString() {
 8     return "{" +
 9       "age=" + age +
10       ‘}‘;
11   }
12   @Override
13   public int compareTo(Person o) {
14     //Person 对象之间根据名字排序
15     return this.age - o.age;
16   }
17 }

排序测试：

public static void main(String[] args) {
        Person[] ps =new Person[]{new Person(1),new Person(4),
new Person(2),new Person(7),new Person(9),new Person(8),
new Person(3),new Person(0),new Person(1)};
        System.out.println("排序前："+Arrays.toString(ps));
          //进行排序
        Arrays.sort(ps);
        System.out.println("排序后："+Arrays.toString(ps));
    }

 

排序前：[{age=1}, {age=4}, {age=2}, {age=7}, {age=9}, {age=8}, {age=3}, {age=0}, {age=1}]
排序后：[{age=0}, {age=1}, {age=1}, {age=2}, {age=3}, {age=4}, {age=7}, {age=8}, {age=9}]

2、Comparator 介绍

如果一个类本身并没有实现 Comparable 接口，我们想要对他进行排序，就要自定义 Comparator 比较器进行比较，在这个比较器里面自定义排序的依据。

Comparator  源码中主要的两个接口方法：

1 public interface Comparator<T>
2  {
3     int compare(T o1, T o2);
4     boolean equals(Object obj);
5  }

compare 是主要方法，必须要实现，equals 方法可以不实现。compare  中返回比较结果，如果该对象小于、等于或大于指定对象，则分别返回负整数、零或正整数。

定义一个用来排序类，该类并为实现 Comparable  接口：

 1 private static class Man{
 2     public int age;
 3     public Man(int age){
 4         this.age = age;
 5     }
 6     public String toString() {
 7         return "{" +
 8                 "age=" + age +
 9                 ‘}‘;
10     }
11 }

进行排序：

 1 @Test
 2 public void test_1(){
 3         Man[] ps =new Man[]{new Man(1),new Man(4),new Man(2),
 4                 new Man(7),new Man(9),new Man(8),new Man(3),new Man(0),new Man(1)};
 5         //数组转List
 6         ArrayList<Man> ap = new ArrayList<Man>(Arrays.asList(ps));
 7 
 8         System.out.println("排序前："+ap);
 9         //自定义排序器
10         Collections.sort(ap,new Comparator<Man>() {
11             @Override
12             public int compare(Man o1, Man o2) {
13               //根据年龄进行排序
14                 return o1.age - o2.age;
15             }
16         });
17 
18         System.out.println("排序后："+ ap);
19 }

 

排序前：[{age=1}, {age=4}, {age=2}, {age=7}, {age=9}, {age=8}, {age=3}, {age=0}, {age=1}]
排序后：[{age=0}, {age=1}, {age=1}, {age=2}, {age=3}, {age=4}, {age=7}, {age=8}, {age=9}]

3、总结比较

Comparable 在类的内部定义排序规则，Comparator 在外部定义排序规则，Comparable 相当于“内部排序器”，Comparator 相当于“外部排序器”，前者一次定义即可，后者可以在不修改源码的情况下进行排序，各有所长。