Java基础之Comparable接口的用法

        Java中的排序是由Comparable和Comparator这两个接口来提供的。

        Comparable表示可被排序的，实现该接口的类的对象自动拥有排序功能。

        Comparator则表示一个比较器，实现了该接口的的类的对象是一个针对目标类的对象定义的比较器，一般情况，这个比较器将作为一个参数进行传递。

 

（一）Comparable

        Comparable的中文意思就是可被排序的，代表本身支持排序功能。只要我们的类实现了这个接口，那么这个类的对象就会自动拥有了可被排序的能力。而且这个排序被称为类的自然顺序。这个类的对象的列表可以被Collections.sort和Arrays.sort来执行排序。同时这个类的实例具备作为sorted map的key和sorted set的元素的资格。

        假如a和b都是实现了Comparable接口的类C的实例，那么只有当a.compareTo(b)的结果与a.equals(b)的结果一致时，才称类C的自然顺序与equals一致。强烈建议将类的自然顺序和equals的结果保持一致，因为如果不一致的话，由该类对象为键的sorted map和由该类对象为元素的sorted set的行为将会变得很怪异。

        例如对于一个实现了Comparable接口的元素的有序集合sorted set而言，如果a.equals(b)结果为false，并且a.compareTo(b)==0，则第二个元素的添加操作将会失败，因为在sorted set看来，二者在排序上是一致的，它不报保存重复的元素。

        事实上，Java中的类基本都是自然顺序与equals一致的，除了BigDecimal，因为BigDecimal中的自然顺序和值相同，但精度不同的元素（例如4和4.00）的equals均一致。 

        源码解析：

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

        从源码中可以看到，该接口只有一个抽象方法compareTo，这个方法主要就是为了定义我们的类所要排序的方式。compareTo方法用于比较当前元素a与指定元素b，结果为int值，如果a > b，int>0；如果a=b，int=0；如果a<b，int<0。

       使用举例：

class Student implements Comparable<Student>{
    int sno;
    int score;
 
    Student(int sno,int score){
        this.sno = sno;
        this.score = score;
    }
 
    @Override
    public int compareTo(Student o) {
        if(this.score<o.score) return -1;
        else if(this.score>o.score) return 1;
        else return 0;
    }
}

 

（二）Comparator

       Comparator中文译为比较器，它可以作为一个参数传递到Collections.sort和Arrays.sort方法来指定某个类对象的排序方式。同时它也能为sorted set和sorted map指定排序方式。

        同Comparable类似，指定比较器的时候一般也要保证比较的结果与equals结果一致，不一致的话，对应的sorted set和sorted map的行为同样会变得怪异。

        源码解析：

@FunctionalInterface
public interface Comparator<T> {
    // 需要实现的抽象方法，用于定义比较方式（即排序方式）
    // o1>o2，返回1；o1=o2，返回0；o1<o2，返回-1
    int compare(T o1, T o2);

    boolean equals(Object obj);
}

        推荐实现的比较器类同时实现java.io.Serializable接口，以拥有序列化能力，因为它可能会被用作序列化的数据结构（TreeSet、TreeMap）的排序方法。   

        特别注意：实现Comparator接口时，需要实现的只有compare方法，而equals方法不用实现。原因是：Java中类都继承于Object类，而Object类默认实现了equals方法，所以不需要必须去实现equals方法。

 

（三）两者比较

        Comparable可以看做是内部比较器，Comparator可以看做是外部比较器。

        一个类可以通过实现Comparable接口来自带有序性，也可以通过额外指定Comparator来附加有序性。

        二者的作用其实是一致的，所以不要混用。

举例：

public class User implements Serializable, Comparable<User> {
    private static final long serialVersionUID = 1L;
    private int age;
    private String name;
 
    public User (){}
 
    public User (int age, String name){
        this.age = age;
        this.name = name;
    }
 
    public int getAge() {
        return age;
    }
 
    public void setAge(int age) {
        this.age = age;
    }
 
    public String getName() {
        return name;
    }
 
    public void setName(String name) {
        this.name = name;
    }
 
    @Override
    public int compareTo(User o) {
        return this.age - o.age;
    }
 
    @Override
    public String toString() {
        return "[user={age=" + age + ",name=" + name + "}]";
    }
}

public class MyComparator implements Comparator<User> {
    @Override
    public int compare(User o1, User o2) {
        return o1.getName().charAt(0)-o2.getName().charAt(0);
    }
}

       测试类：

public class Main {
 
    public static void main(String[] args) {
        User u1 = new User(12, "xiaohua");
        User u2 = new User(10, "abc");
        User u3 = new User(15,"ccc");
        User[] users = {u1,u2,u3};
        System.out.print("数组排序前：");
        printArray(users);
        System.out.println();
        Arrays.sort(users);
        System.out.print("数组排序1后：");
        printArray(users);
        System.out.println();
        Arrays.sort(users, new MyComparator());
        System.out.print("数组排序2后：");
        printArray(users);
        System.out.println();
        Arrays.sort(users, Comparator.reverseOrder());// 针对内置的排序进行倒置
        System.out.print("数组排序3后：");
        printArray(users);
    }
 
    public static void printArray (User[] users) {
        for (User user:users) {
            System.out.print(user.toString());
        }
    }
}

       注意：两种方式定义排序的优先级，Comparator比较器要优先于内部排序Comparable。