Comparable与Comparator的区别

1.理论知识

1. Comparable
   实现Comparable接口，重写compareTo方法。一般在实体类定义的时候就可以选择实现该接口，提供一个默认的排序方式，供Arrays.sort和Collections.sort使用，只有一种排序方式，很难满足复杂的排序要求。

compareTo方法的返回值是int，有三种情况：
a、当前对象大于被比较对象（compareTo方法里面的形参），返回正整数
b、当前对象等于被比较对象，返回0
c、当前对象小于被比较对象，返回负整数

2. Comparator
   实现Comparator接口，重写compare方法，一般在实体类中未定义排序方法或实体类中的排序方法不满足需求的情况下来实现该接口。实现方法可以是写一个比较器类，也可是匿名内部类。实现方式灵活，可以提供多种排序选择。

Ccompare方法有两个参数o1和o2，分别表示待比较的两个对象，方法返回值也是int，有三种情况：
a、o1大于o2，返回正整数
b、o1等于o2，返回0
c、o1小于o2，返回负整数

2.代码验证

上代码

实体类Student,实现Comparable接口

public class Student implements Comparable<Student> {
    private int age;
    private String address;
    private int score;

    public Student(int age, String address, int score) {
        this.age = age;
        this.address = address;
        this.score = score;
    }

    public int getAge() {
        return age;
    }

    public String getAddress() {
        return address;
    }

    public int getScore() {
        return score;
    }

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

    public void setAddress(String address) {
        this.address = address;
    }

    public void setScore(int score) {
        this.score = score;
    }

    @Override
    public String toString() {
        return "Student{" +
                "age=" + age +
                ", address='" + address + '\'' +
                ", score=" + score +
                '}';
    }

    @Override
    public int compareTo(Student o) {
//        return this.age - o.age;
        return o.age - this.age;
    }
}

测试类

public class SortTest {
    public static void main(String[] args) {
        Student s1 = new Student(18, "西安", 98);
        Student s2 = new Student(6, "广州", 68);
        Student s3 = new Student(29, "天水", 84);
        Student s4 = new Student(18, "广州", 84);
        Student[] students = new Student[4];
        students[0] = s1;
        students[1] = s2;
        students[2] = s3;
        students[3] = s4;
        Arrays.sort(students);
//        Arrays.sort(students,new StudentScoreComparator());
//        Arrays.sort(students, new Comparator<Student>() {
//            @Override
//            public int compare(Student o1, Student o2) {
//                return o1.getScore() - o2.getScore();
//            }
//        });
//        Arrays.sort(students, (o1, o2) -> o1.getScore() - o2.getScore());
//        Arrays.sort(students, Comparator.comparingInt(Student::getScore));
        for (int i = 0; i < students.length; i++) {
            System.out.println(students[i]);
        }

    }
}

比较器类

public class StudentScoreComparator implements Comparator<Student> {
    @Override
    public int compare(Student o1, Student o2) {
        if (o1.getScore() == o2.getScore()) {
            return o1.getAge() - o2.getAge();
        }
        return o2.getScore() - o1.getScore();
    }
}

1. 使用默认排序（前提是实体类实现Comparable接口，否则会报错）

Arrays.sort(students);
compareTo方法：用age字段排序
正序：this.age - o.age;
逆序：o.age - this.age;

2. 使用比较器类排序
   Arrays.sort(students,new StudentScoreComparator());
   compare方法：score逆序，age正序
   正序：o1-o2
   逆序：o2-o1

3. 匿名内部类排序：score正序
   Arrays.sort(students, new Comparator() {
   @Override
   public int compare(Student o1, Student o2) {
   return o1.getScore() - o2.getScore();
   }
   });

lambda简化：Arrays.sort(students, (o1, o2) -> o1.getScore() - o2.getScore());

正序可以再简化，逆序不行
Arrays.sort(students, Comparator.comparingInt(Student::getScore));

3.按照请求列表顺序返回

// 预定义的姓名顺序
List<String> studentNamesOrder = Arrays.asList("Alice", "Bob", "Charlie", "David", "Eve");

// 按照姓名顺序排序
students.sort(Comparator.comparingInt(student -> studentNamesOrder.indexOf(student.getName())));

这段代码是用来对一个学生列表进行排序的，排序的依据是学生姓名在一个预定义顺序列表中的索引位置。让我们来分解一下这段代码的作用和实现方式：
代码解析

 studentNamesOrder.indexOf(student.getName())
        studentNamesOrder 是一个预定义的列表，包含了学生姓名的顺序。indexOf 方法用于查找特定学生姓名在 studentNamesOrder 中的索引位置。

    Comparator.comparingInt(...)
        这部分是 Java 8 引入的函数式接口 Comparator 的静态方法，用于创建一个比较器对象。在这里，使用了 comparingInt 方法，它接受一个函数作为参数，该函数产生整数类型的比较值。

    student -> studentNamesOrder.indexOf(student.getName())
        这是一个 Lambda 表达式，作为 comparingInt 方法的参数。它表示对每个学生对象 student，返回其姓名在 studentNamesOrder 中的索引值作为比较值。

    students.sort(...)
        students 是一个学生对象的列表，sort 方法用来对列表中的元素进行排序。排序的依据是上述 Comparator 对象返回的比较值。

实际应用

可以实现按照 studentNamesOrder 中定义的顺序对 students 列表中的学生对象进行排序。

class Student {
    private String name;
    private int age;

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

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

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

public class SortTest {
    public static void main(String[] args) {
        // 定义学生列表
        List<Student> students = new ArrayList<>();
        students.add(new Student("David", 25));
        students.add(new Student("Alice", 20));
        students.add(new Student("Bob", 22));
        students.add(new Student("Eve", 19));
        students.add(new Student("Charlie", 21));

        // 预定义的姓名顺序
        List<String> studentNamesOrder = Arrays.asList("Alice", "Bob", "Charlie", "David", "Eve");

        // 按照姓名顺序排序
        students.sort(Comparator.comparingInt(student -> studentNamesOrder.indexOf(student.getName())));

        // 输出排序后的学生列表
        System.out.println("按照 studentNames 中的姓名顺序排序后的学生列表：");
        for (Student student : students) {
            System.out.println(student);
        }
    }
}