Java 之 比较器（ Comparator接口与 Comparable 接口）

一、定制排序：java.util.Comparator 接口

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

　　当元素的类型没有实现java.lang.Comparable接口而又不方便修改代码，或者实现了java.lang.Comparable接口的排序规则不适合当前的操作，那么可以考虑使用 Comparator 的对象来排序。

java.util.Comparator<T>接口：
    抽象方法：int compare(T o1, T o2)

　　<T> 是泛型，可以理解成 Object。

　　java.util.Comparator接口：

　　　　抽象方法：int compare(Object o1, Object o2)

　　说明：这个接口是代表 Java 中比较两个对象的大小标准。而且是一种“定制”比较的标准。

　　　　　这个接口中没有规定如何比较两个对象的大小。

　　　　　但是规定了：如果认为 o1 大于 o2，那么就返回正整数表示；

　　　　　　　　　　　如果认为 o1 小于 o2，那么就返回负整数表示；

　　　　　　　　　　　如果认为 o1 等于 o2，那么就返回0表示；

　　需求：声明一个学生类，实现 comparator 接口，来定制两个学生比较的具体实现方式

　　Demo：

　　学生类：

class Student{
    private String name;
    private int age;
    private int score;
    public Student(String name, int age, int score) {
        super();
        this.name = name;
        this.age = age;
        this.score = score;
    }
    public Student() {
        super();
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public int getScore() {
        return score;
    }
    public void setScore(int score) {
        this.score = score;
    }
    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + ", score=" + score + "]";
    }
    
}

　　测试类：

public class TestComparator {
    public static void main(String[] args) {
        Student s1 = new Student("小李子", 25, 89);
        Student s2 = new Student("小张字", 24, 99);
        
        
        AgeComparator c = new AgeComparator();
        if(c.compare(s1, s2) > 0){            //如果比较s1，s2的结果是正整数，说明s1>s2
            System.out.println("s1 > s2的年龄");
        }else if(c.compare(s1, s2) <0){
            System.out.println("s1 < s2的年龄");
        }else{
            System.out.println("s1 = s2的年龄");
        }
        
        
        Student[] all = new Student[5];
        all[0] = s1;
        all[1] = s2;
        all[2] = new Student("张三",22,87);
        all[3] = new Student("李四",24,44);
        all[4] = new Student("王五",25,45);
        
        //Arrays工具类
        //Arrays.sort(all);
        /*
         * public static void sort(Object[] a, Comparator c)
         * 第一个形参：需要排序的数组，Object[]说明可以是任意类型的对象数组
         * 第二个形参：比较器对象     Comparator接口不能创建对象，只能传入实现类对象
         */
        Arrays.sort(all, new AgeComparator());
    
        for (int i = 0; i < all.length; i++) {
            System.out.println(all[i]);
        }
    }
}

//实现Comparator接口，来定制两个学生比较的具体实现方式
//例如：按照年龄比较
class AgeComparator implements Comparator{

    @Override
    public int compare(Object o1, Object o2) {
        //（1）向下转型
        Student s1 = (Student) o1;
        Student s2 = (Student) o2;
        
        //（2）开始比较
        if(s1.getAge() > s2.getAge()){
            return 1;
        }else if(s1.getAge() < s2.getAge()){
            return -1;
        }
        return 0;
    }
    
}

二、自然排序：java.lang.Comparable 接口

　　Comparable接口强行对实现它的每个类的对象进行整体排序。这种排序被称为类的自然排序，类的 compareTo(T t) 方法被称为它的自然比较方法。当前对象this与指定对象t比较“大小”，如果当前对象this大于指定对象t，则返回正整数，如果当前对象this小于指定对象t，则返回负整数，如果当前对象this等于指定对象t，则返回零。

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

　　Comparable 的典型实现：

String：按照字符串中字符的Unicode值进行比较

Character：按照字符的Unicode值来进行比较

 数值类型对应的包装类以及BigInteger、BigDecimal：按照它们对应的数值大小进行比较

 Date、Time等：后面的日期时间比前面的日期时间大

java.lang.Comparable：自然比较，自然顺序
       int compareTo(Object obj)

　　this 与 obj 对象比较，this > obj，返回正整数；

　　this 与 obj 对象比较，this < obj，返回负整数；

　　this 与 obj 对象比较，this = obj，返回0；　　　

　对于上面的案例来说，如果希望学生对象本身就具备比较大小的能力。可以使学生实现 Comparable 接口。

　代码：

public class TestComparable {
    public static void main(String[] args) {
        Student s1 = new Student("小李子", 25, 89);
        Student s2 = new Student("小张字", 24, 99);
        
        //按成绩比较
        if(s1.compareTo(s2)>0){
            System.out.println("s1 > s2成绩");
        }else if(s1.compareTo(s2)<0){
            System.out.println("s1 < s2成绩");
        }else{
            System.out.println("s1 = s2成绩");
        }
        
        
    }
}
class Student implements Comparable{
    private String name;
    private int age;
    private int score;
    public Student(String name, int age, int score) {
        super();
        this.name = name;
        this.age = age;
        this.score = score;
    }
    public Student() {
        super();
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public int getScore() {
        return score;
    }
    public void setScore(int score) {
        this.score = score;
    }
    @Override
    public String toString() {
        return "Student [name=" + name + ", age=" + age + ", score=" + score + "]";
    }
    @Override
    public int compareTo(Object obj) {
        //this与obj比较，this和obj都是学生对象
        Student other = (Student) obj;
        //例如：对于学生对象来说，最常用的是按成绩排名，那么我就可以把自然顺序定位成绩升序
/*        if(this.score > other.score){
            return 1;
        }else if(this.score < other.score){
            return -1;
        }
        return 0;*/
        
        return this.score - other.score;
    }
}

　　总结：

　　　　Arrays 的 sort 方法有两种：

　　　（1）void sort(Object[] arr)

　　　　　  根据元素的自然顺序对指定对象数组按升序进行排序，数组中的所有元素必须实现 Comparable 接口。

　　　（2）void sort(Object[] arr, Comparator c)

　　　　　  根据“指定比较器”产生的顺序对指定对象数组进行排序，数组中的所有元素都必须是通过“指定比较器”可相互比较的。