【Java】对象数组排序（Comparable接口/Comparator接口）

Comparable接口（compareTo）

Arrays 类中的 sort 方法承诺可以对对象数组进行排序，但要求满足下列前提：对象所属的类必须实现了 Comparable 接口，且定义了compareTo方法。

Comparable接口的代码

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

在 JavaSE 5.0 中，Comparable 接口已经改进为泛型类型。

代码实例

希望使用 Arrays 类的 sort 方法对 Employee 对象数组进行排序， Employee 类就必须实现Comparable 接口。这里的 Employee 类需要提供 compareTo 方法。 假设希望根据雇员的薪水进行比较。
我们使用泛型Comparable接口举例，泛型接口的好处是不需要对Object类型参数进行强制转换。

首先实现Comparable并定义compareTo方法，按薪水进行比较

public class Employee implements Comparable<Employee>{
    private Double salary;
    private String name;

    public Employee(Double salary) {
        this.salary = salar y;
    }
    @Override
    public int compareTo(Employee other) {
        return Double.compare(this.getSalary(),other.getSalary());
    }
    //.....省略
}

然后进行测试，输出排序后数组中对象的薪水

    public static void main(String[] args) {
        Employee[] staff = new Employee[3];

        staff[0] = new Employee(3000.0);
        staff[1] = new Employee(2000.0);
        staff[2] = new Employee(4000.0);
        //排序
        Arrays.sort(staff);
        //输出薪水
        for(Employee e : staff){
            System.out.println(e.getSalary());
        }

    }

排序后的输出结果为

Comparator接口（compare）

问题

要处理这种情况，ArrayS.Sort 方法还有第二个版本， 有一个数组和一个比较器 ( comparator )作为参数， 比较器是实现了 Comparator 接口的类的实例。

Comparator接口

要按长度比较字符串，可以如下定义一个实现 Comparator<> 的类

具体完成比较时，需要建立一个实例

将这个调用与 words[i].compareTo(words[j]) 做比较。这个 compare 方法要在比较器对象上调用，而不是在字符串本身上调用。

代码示例，按字符串长度排序

定义比较器类和compare方法，实现了Comparator泛型接口

public class StringLengthComparator implements Comparator<String> {
    @Override
    public int compare(String o1, String o2) {
        return o1.length()-o2.length();
    }
}

测试。按字符串长度排序，Arrays.sort第一个参数为字符串数组，第二个参数为比较器实例

    String[] strs = {"abcd","adfcsd","aa"};
    //按字符串长度排序,传入比较器对象
    Arrays.sort(strs,new StringLengthComparator());
    for (String item : strs){
        System.out.println(item);
    }

输出结果

代码示例，Employee 对象数组进行排序，实现方式2

修改之前使用Comparable接口的方法实现的对象数组排序，改用使用实现Comparator接口的比较器实现对象数组排序。
这样Employee类不用实现Comparable接口也能实现对象数组的排序。

实现方式2，定义比较器类 EmployeeComparator 和 compare 方法，实现了Comparator泛型接口

public class EmployeeComparator implements Comparator<Employee> {
    @Override
    public int compare(Employee o1, Employee o2) {
        return Double.compare(o1.getSalary(),o2.getSalary());
    }
}

测试，Arrays.sort中传入对象数组，和比较器实例

    Employee[] employees = new Employee[3];
    employees[0] = new Employee(2000.0);
    employees[1] = new Employee(1000.0);
    employees[2] = new Employee(3000.0);
	//EmployeeComparator 为比较器
    Arrays.sort(employees,new EmployeeComparator());
    for(Employee e : employees){
        System.out.println(e.getSalary());
    }

输出结果

Comparator与Comparable接口的不同

● 如果实现Comparable接口则是在 需要比较的对象上调用 compareTo方法
● 如果实现Comparator接口则是 使用在比较器实例调用 compare方法