Comparable和Comparator的比较与使用

Comparable与Comparator的使用

从字面意思我们就可以看出，Comparable是具有比较能力的，Comparator是比较器，那么前者很显然是指某个对象具有比较能力的，就好像是一种技能，而后者是给一个比较的工具，我们使用这个工具来进行比较。

Comparable

Comparable接口中只有一个方法：

public interface Comparable<T> {
    // 返回值:
    // < 0: 表示 this 指向的对象小于 o 指向的对象
    // == 0: 表示 this 指向的对象等于 o 指向的对象
    // > 0: 表示 this 指向的对象等于 o 指向的对象
    public int compareTo(T o);
}

在java中的很多类都实现了这个接口，比方说Integer、Long等包装类，String类等等。

实例：某个班有若干学生，现需要进行按身高进行排队（从小到大）。

分析：需要一个学生类，学生类需要具备比较能力（Comparable），所以其内部必须实现compareTo方法。

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class Student implements Comparable<Student>{
    private String name;//姓名
    private int hight;//身高

    public Student(String name, int hight) {
        this.name = name;
        this.hight = hight;
    }

    public String getName() {
        return name;
    }

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

    public double getHight() {
        return hight;
    }

    public void setHight(int hight) {
        this.hight = hight;
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", hight=" + hight +
                '}';
    }

    @Override
    public int compareTo(Student stu) {
        if(this.hight == stu.hight){
            return 0;
        }else if(this.hight > stu.hight){
            return 1;
        }else{
            return -1;
        }
    }

    public static void main(String[] args) {
        List<Student> stus = new ArrayList<>();
        Student stu1 = new Student("张三",177);
        Student stu2 = new Student("李四",160);
        Student stu3 = new Student("王五",182);
        Student stu4 = new Student("赵六",165);

        stus.add(stu1);
        stus.add(stu2);
        stus.add(stu3);
        stus.add(stu4);

        Collections.sort(stus);
        for(Student s : stus){
            System.out.println(s);
        }
    }
}

运行结果：

Comparator

Comparator中根据JDK版本不同，其方法的数量不同，但是值得注意的是，它是一个函数式接口，所以可以使用lambda表达式。

@FunctionalInterface
public interface Comparator<T> {
    // 返回值:
    // < 0: 表示 this 指向的对象小于 o 指向的对象
    // == 0: 表示 this 指向的对象等于 o 指向的对象
    // > 0: 表示 this 指向的对象等于 o 指向的对象
    int compare(T o1, T o2);
    boolean equals(Object obj);
}

@FunctionalInterface该注解表示函数式接口，接口内除object的public方法外，只有一个抽象方法。

实例：公司有若干员工，需要对其工资进行排序（从大到小）

分析：需要员工类，在员工集合中对其进行排序，传入比较器，这里直接匿名实现。

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

public class Employee {
    private String name;//员工姓名
    private int Salary;//月工资

    public Employee(String name, int salary) {
        this.name = name;
        this.Salary = salary;
    }

    public String getName() {
        return name;
    }

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

    public int getSalary() {
        return Salary;
    }

    public void setSalary(int salary) {
        Salary = salary;
    }

    @Override
    public String toString() {
        return "Employee{" +
                "name='" + name + '\'' +
                ", Salary=" + Salary +
                '}';
    }

    public static void main(String[] args) {
        List<Employee> list = new ArrayList<>();
        Employee emp1 = new Employee("张三",5000);
        Employee emp2 = new Employee("李四",6000);
        Employee emp3 = new Employee("王五",4500);
        Employee emp4 = new Employee("赵六",8000);

        list.add(emp1);
        list.add(emp2);
        list.add(emp3);
        list.add(emp4);

        Collections.sort(list, new Comparator<Employee>() {
            @Override
            public int compare(Employee o1, Employee o2) {
                if(o1.Salary == o2.Salary){
                    return 0;
                }else if(o1.Salary > o2.Salary){
                    return -1;
                }else{
                    return 1;
                }
            }
        });
        for(Employee e:list){
            System.out.println(e);
        }
    }
}

运行结果：

使用lambda表达式：

//使用lambda表达式
        Collections.sort(list,(o1,o2)->{
            if(o1.Salary == o2.Salary){
                return 0;
            }else if(o1.Salary > o2.Salary){
                return -1;
            }else{
                return 1;
            }
        });

因为比较的本身就是int，可以利用compare的返回值特性使其变得更简化。上面Comparable也是如此。

    //使用lambda表达式，并利用compare返回值特性更简化。
    Collections.sort(list,((o1, o2) -> (o2.Salary - o1.Salary)));