Java的比较器

Java的比较器

比较器使用场景

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

在java中经常涉及到对象数组的比较的情况，常见的有两种方法来处理：

1. 继承comparable接口，并实现compareTo()方法
2. 定义一个单独的对象比较器，继承自Comparator接口，实现compare()方法

Comparable

Comparable 简介

Comparable 是排序接口。
若一个类实现了Comparable接口，就意味着“该类支持排序”。 即然实现Comparable接口的类支持排序，假设现在存在“实现Comparable接口的类的对象的List列表(或数组)”，则该List列表(或数组)可以通过 Collections.sort（或 Arrays.sort）进行排序。
此外，“实现Comparable接口的类的对象”可以用作“有序映射(如TreeMap)”中的键或“有序集合(TreeSet)”中的元素，而不需要指定比较器。

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

x.compareTo(y) 来“比较x和y的大小”。若返回“负数”，意味着“x比y小”；返回“零”，意味着“x等于y”；返回“正数”，意味着“x大于y”。

Comparable的demo

Employee类

public class Employee implements Comparable<Employee>{
    private String name;
    private Integer age;
    private double salary;

    public Employee(String name, Integer age, double salary) {
        this.name = name;
        this.age = age;
        this.salary = salary;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public Integer getAge() {
        return age;
    }

    public void setAge(Integer age) {
        this.age = age;
    }

    public double getSalary() {
        return salary;
    }

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

    public Employee() {
    }

    @Override
    public int compareTo(Employee o) {
        if (salary!=o.salary) {
            //大的结果为1，1的在后面，想实现降序，*-1
            return Double.compare(salary, o.salary)*-1;
        }
        else {
            return Integer.compare(age, o.age)*-1;
        }
    }
}

测试类

public class Test {
    public static void main(String[] args) {
        Employee[] staff = new Employee[5];
        staff[0] = new Employee ("小明",20,3333.44) ;
        staff[1] = new Employee ("小红",21,3333.44);
        staff[2] = new Employee ("小白",20,3355.44);
        staff[3] = new Employee("小黑",18,2222.2);
        staff[4] = new Employee("小紫",30,333333);
        for (Employee employee : staff) {
            System.out.println("姓名："+employee.getName()+" 年龄: "+employee.getAge()+" 工资："+employee.getSalary());
        }
        System.out.println("----------------------------------");
        //方法一，排序的类实现Comparable接口
        Arrays.sort(staff);
         for (Employee employee : staff) {
            System.out.println("姓名："+employee.getName()+" 年龄: "+employee.getAge()+" 工资："+employee.getSalary());
        }
    }
}

注意：

• 使用Comparable接口进行对象数组的排序，必须对应对象的类实现Comparable接口并重写compareTo方法

• x.compareTo(y) 来“比较x和y的大小”。若返回“负数”，意味着“x比y小”；返回“零”，意味着“x等于y”；返回“正数”，意味着“x大于y”。

• 默认是降序排序，大的在上面，想实现所需排序，把返回的结果*-1即可

优化：

我们在之前的博客中提及到stream流的特性，我们这里出于是数组，可以借助流来遍历，下面的例子直接使用流遍历

Arrays.stream(staff).forEach(employee->System.out.println("姓名："+employee.getName()+" 年龄: "+employee.getAge()+" 工资："+employee.getSalary()));

结果相同，当是代码简洁了很多

Comparator

Comparator 简介

Comparator 是比较器接口。
我们若需要控制某个类的次序，而该类本身不支持排序(即没有实现Comparable接口)；那么，我们可以建立一个“该类的比较器”来进行排序。这个“比较器”只需要实现Comparator接口即可。也就是说，我们可以通过“实现Comparator类来新建一个比较器”，然后通过该比较器对类进行排序。

public interface Comparator {
	int compare(T o1, T o2);
	boolean equals(Object obj);
}

AgeComparator

public class AgeComparator implements Comparator<Employee> {
    @Override
    public int compare(Employee o1, Employee o2) {
        return o1.getAge()-o2.getAge();
    }
}

测试

public class Test {
    public static void main(String[] args) {
        Employee[] staff = new Employee[5];
        staff[0] = new Employee("小明", 20, 3333.44);
        staff[1] = new Employee("小红", 21, 3333.44);
        staff[2] = new Employee("小白", 20, 3355.44);
        staff[3] = new Employee("小黑", 18, 2222.2);
        staff[4] = new Employee("小紫", 30, 333333);
        Arrays.stream(staff).forEach(employee->System.out.println("姓名："+employee.getName()+" 年龄: "+employee.getAge()+" 工资："+employee.getSalary()));
        System.out.println("----------------------------------");

        Arrays.sort(staff,new AgeComparator());
        Arrays.stream(staff).forEach(employee->System.out.println("姓名："+employee.getName()+" 年龄: "+employee.getAge()+" 工资："+employee.getSalary()));
    }
}

注意：

• 默认是升序，想降序可以乘以-1
• compareTo(x,y) 来“比较x和y的大小”。若返回“负数”，意味着“x比y小”；返回“零”，意味着“x等于y”；返回“正数”，意味着“x大于y”。

优化：

我们在之前的学习中，知道lambda表达式可以简化我们代码，当是lambda表达式的使用条件是接口必须是函数式接口（只有一个抽象方法的接口）——这里的Comparator就是一个抽象接口

可能会有人有疑惑：Comparator接口有很多方法，不是接口的方法都是抽象的么？，怎么会是函数式接口

理论证据：

实际上， 接口完全有可能重新声明 Object 类的方法， 如 toString 或 clone或者equals，这些声明有可能会让方法不再是抽象的。

（ Java API 中的一些接口会重新声明 Object 方法，来附加 javadoc 注释。Comparator API就是这样一个例子。

而且在java8后，接口可以声明非抽象方法，可以有方法体

实际证据：

实现类可以只实现compare方法（实现类必须实现接口的全部抽象方法）——这点证明Comparator是函数式接口

为了展示如何转换为函数式接口，下面考虑 Arrays.sort 方法，它的第二个参数需要一个Comparator 实例， Comparator 就是只有一个方法的接口， 所以可以提供一个 lambda 表达式

我们重写Test类的main方法

public static void main(String[] args) {
        Employee[] staff = new Employee[5];
        staff[0] = new Employee("小明", 20, 3333.44);
        staff[1] = new Employee("小红", 21, 3333.44);
        staff[2] = new Employee("小白", 20, 3355.44);
        staff[3] = new Employee("小黑", 18, 2222.2);
        staff[4] = new Employee("小紫", 30, 333333);
        Arrays.stream(staff).forEach(employee->System.out.println("姓名："+employee.getName()+" 年龄: "+employee.getAge()+" 工资："+employee.getSalary()));
        System.out.println("----------------------------------");
    	//lambda表达式写法1
        Arrays.sort(staff,(Employee e1,Employee e2)->{
            if (e1.getAge() - e2.getAge()>0){
                return 1;
            }
            else if (e1.getAge() - e2.getAge()<0){
                return -1;
            }
            else return 0;
        });
   	 	//lambda表达式写法2
    	Comparator<Employee> comparator = (Employee e1,Employee e2)->{
            if (e1.getAge() - e2.getAge()>0){
                return 1;
            }
            else if (e1.getAge() - e2.getAge()<0){
                return -1;
            }
            else return 0;
        };
        Arrays.sort(staff,comparator);
    	//遍历
        Arrays.stream(staff).forEach(employee->System.out.println("姓名："+employee.getName()+" 年龄: "+employee.getAge()+" 工资："+employee.getSalary()));
    }

在底层， Arrays.sort 方法会接收实现了 Comparator 的某个类的对象，在这个对象上调用 compare 方法会执行这个 lambda 表达式的体。这些对象和类的管理完全取决于具体实现， 与使用传统的内联类相比，这样可能要高效得多。最好把 lambda 表达式看作是一个函数，而不是一个对象， 另外要接受 lambda 表达式可以传递到函数式接口。

Comparator 和 Comparable 比较

• Comparable是排序接口；若一个类实现了Comparable接口，就意味着“该类支持排序”。
• 而Comparator是比较器；我们若需要控制某个类的次序，可以建立一个“该类的比较器”来进行排序。
• 我们不难发现：Comparable相当于“内部比较器”，而Comparator相当于“外部比较器”。