Comparable和CompareTo还有Comparator

这几个概念老是记不住，每次使用都要百度真是难受特将作用记下来。

1、Comparable 是一个接口，Arrays类中的 sort 方法承诺可以对对象数组进行排序，但要求满 足下列前提：对象所属的类必须实现了 Comparable 接口，下面是 Comparable 接口的代码：

public interface Comparable 
{ 
int compareTo(Object other);
} 

在调用 X.c0mpareT0(y) 的时候，这个 compareTo方法必须确实比较两个对象的内容， 并返回比较的结果。 当 x 小于 y时， 返回一 个负数；当 x 等于 y时， 返回 0; 否则返回一个正数。 

应用举例：对于一个对象根据两种不同实例数据进行排序。

Employee类继承Comparable接口，实现接口中的方法：

import static java.lang.Integer.compare;

public class Employee implements Comparable {

    int age;
    int score;
    Employee(int age,int score)
    {
        this.age=age;
        this.score=score;
    }

    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 "Employee{" +
                "age=" + age +
                ", score=" + score +
                '}';
    }

    @Override
    public int compareTo(Object o) {
       Employee otherEmployee=(Employee) o;
        int res=compare(age,otherEmployee.age);
        return res==0? compare(otherEmployee.score,score):res;
    }
}

Test测试方法

public class Test {

    public static void main(String[] args) {

        Employee [] staff=new Employee[3];
        staff[0]=new Employee(3,8);
        staff[1]=new Employee(12,9);
        staff[2]=new Employee(12,23);
        Arrays.sort(staff);
        for(Employee e:staff)
        {
            System.out.println(e);
        }

    }
}

2.Comparator 是一个外部比较器，在排序过程中作为参数传递给sort函数，类似于Arrays.sort(array,比较器)；

实现代码如下，也是对两个元素进行排序

User类

package compare;

public class User {

    public int workYears;
    public int salary;

    public User(int workYears, int salary) {
        this.workYears = workYears;
        this.salary = salary;
    }

    public int getWordYears() {
        return workYears;
    }

    public void setWordYears(int wordYears) {
        this.workYears = wordYears;
    }

    public int getSalary() {
        return salary;
    }

    public void setSalary(int salary) {
        this.salary = salary;
    }

    @Override
    public String toString() {
        return "User{" +
                "wordYears=" + workYears +
                ", salary=" + salary +
                '}';
    }
}

Test2进行比较

public class Test2 {

    public static void main(String[] args) {

        User [] users=new User[4];
        users[0]=new User(1,5);
        users[1]=new User(4,0);
        users[2]=new User(2,3);
        users[3]=new User(2,2);
        int [] arr={2,5,1,8,5,6,9,3,2};


        Arrays.sort(users, new Comparator<User>() {
            @Override
            public int compare(User o1, User o2) {

                return o1.wordYears==o2.wordYears? o1.salary-o2.salary:o1.wordYears-o2.wordYears;
            }
        });


        /*Arrays.sort(users,(o1,o2)->o1.workYears==o2.workYears?o1.salary-o2.salary:o1.workYears-o2.workYears);*/

        for(User user:users)
        {
            System.out.println(user);
        }
    }
}

3.Lambda 表达式取代内部类的作用，例如上述代码的 new  Comparator<User>(){...}部分可以替换为

        Arrays.sort(users,(o1,o2)->o1.workYears==o2.workYears?o1.salary-o2.salary:o1.workYears-o2.workYears);

一行代码就搞定了。

总结：Comparable是类必须继承后才能排序的接口，比较不灵活，对于一些本身就一定要实现排序的类建议实现该接口。

Comparator是一个比较器，即使之前的类没有定义比较器，也可以在调用sort方法时候，将比较器作为参数传进去。实现灵活的配置和比较。

至于compareTo和compare分别是Comparable接口的实现方法和Comparator的实现方法。