Java中自定义对象比较规则

        平常我们给数值、字符、字符串排序时，可以使用内置的API、手写各种排序算法（冒泡、插入、选择...），来实现排序功能，当我们想给一群不同类对象排序时，就需要我们自己动手来创建排序规则了，这里要用到两个接口Comparable和Comparator。

基本类型的排序

1、内置API

使用内置Collections工具类中的sort方法实现排序（默认升序），第二个参数加Collections工具类中的reverseOrder() 方法可以方便地实现逆序排序

public class Main {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(5);
        list.add(2);
        list.add(9);
        list.add(1);
        list.add(7);
        System.out.println("排序前：" + list);
        //升序
        Collections.sort(list);
        System.out.println("升序排序后：" + list);
        //降序
        Collections.sort(list,Collections.reverseOrder()); 
        System.out.println("降序排序后：" + list);
    }
}
//输出结果为：
//排序前：[5, 2, 9, 1, 7]
//升序排序后：[1, 2, 5, 7, 9]
//降序排序后：[9, 7, 5, 2, 1]

2、匿名内部类形式

public class Main {
    public static void main(String[] args) {
        List<Integer> list = new ArrayList<>();
        list.add(5);
        list.add(2);
        list.add(9);
        list.add(1);
        list.add(7);
        System.out.println("排序前：" + list);
        // 自定义比较器
        Comparator<Integer> reverseOrder = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2.compareTo(o1);
            }
        };
        //降序
        Collections.sort(list,reverseOrder); 
        System.out.println("自定义降序排序后：" + list);
    }
}
//输出结果为：
//排序前：[5, 2, 9, 1, 7]
//自定义降序排序后：[9, 7, 5, 2, 1]

这段代码是创建了一个匿名内部类，它实现了Comparator接口，并重写了compare方法。

匿名内部类是在定义的同时进行实例化的一种特殊形式，它没有显式的类名称，只能通过创建的对象来使用。

在这个例子中，匿名内部类被赋值给了reverseOrder对象，用于实现倒序比较两个整数。

以上两种方法都可以将集合进行逆序排序，而自定义比较器则更加灵活，可以根据具体需求自定义排序规则。

自定义比较规则---（集合）

一、实现Comparator接口

class Student {
    private String name;
    private int age;
    // 构造函数、getter和setter省略...
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
               '}';
    }
}
class AgeComparator implements Comparator<Student> {
    @Override
    public int compare(Student s1, Student s2) {
        return Integer.compare(s1.getAge(), s2.getAge());
    }
}
public class SortingExample {
    public static void main(String[] args) {
        List<Student> students = new ArrayList<>();
        students.add(new Student("Alice", 20));
        students.add(new Student("Bob", 19));
        students.add(new Student("Charlie", 22));

        // 使用自定义的比较器进行排序
        Collections.sort(students, new AgeComparator());
        // 打印排序后的结果
        for (Student student : students) {
            System.out.println(student);
        }
    }
}

二、实现Comparable接口

以下代码的含义是：首先按学生的成绩降序排序，对于成绩相同的学生，则按年龄升序排序，主要功能实现在compareTo方法中。

class Student implements Comparable<Student>{//指定类型为 Student
    private String name;
    private int age;
    private float score;
    public Student(String name,int age,float score){
        this.name = name;
        this.age = age;
        this.score = score;
    }
    public String toString(){  return name + "\t\t" + age + "\t\t" + score;    }

    public int compareTo(Student stu){
        //覆写 compareTo() 方法，实现排序规则的应用
        if (this.score>stu.score){
            return -1;
        }else if(this.score < stu.score){
            return 1;
        }else {
            if (this.age > stu.age){
                return 1;
            }else if (this.age<stu.age){
                return -1;
            }else {
                return 0;
            }
        }
    }
}
public class Root{
    public static void main(String[] args) {
        Student[] stu = {new Student("stu1",20,90.0f),
        new Student("stu2",22,90.0f),
        new Student("stu3",20,70.0f),
        new Student("stu4",34,98)};
        Arrays.sort(stu);
        for (Student x:stu){
            System.out.println(x);
        }
    }
}

自定义比较规则---（数组）

上面介绍的是集合，下面介绍针对数组

给数组自定义排序规则与集合十分类似

模板：

Arrays.sort(数组[,比较器对象]);
"[]"：表示可选

一、实现Comparator接口

public class Main {
    public static void main(String[] args) {
        Person[] persons = new Person[3];
        persons[0] = new Person("Alice", 25);
        persons[1] = new Person("Bob", 30);
        persons[2] = new Person("Carol", 20);

        Arrays.sort(persons, new AgeComparator());

        for (Person person : persons) {
            System.out.println(person);
        }
    }
}
class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
class AgeComparator implements Comparator<Person> {
    @Override
    public int compare(Person p1, Person p2) {
        return p1.getAge() - p2.getAge();
    }
}

二、实现Comparable接口

public class Main {
    public static void main(String[] args) {
        Person[] persons = new Person[3];
        persons[0] = new Person("Alice", 25);
        persons[1] = new Person("Bob", 30);
        persons[2] = new Person("Carol", 20);

        Arrays.sort(persons);

        for (Person person : persons) {
            System.out.println(person);
        }
    }
}
class Person implements Comparable<Person> {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public int compareTo(Person other) {
        return this.age - other.age;
    }
    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

实现Comparable和Comparator的区别：

Comparator接口的实现是独立于要排序的类的。可以在任意地方创建一个比较器类，实现Comparator接口并重写compare()方法来定义排序规则。
在compare()方法中，比较器根据自定义的规则来确定两个对象之间的关系。

Comparable接口的实现是针对需要排序的类本身，在类中通过实现Comparable接口并重写compareTo()方法来定义排序规则。
例如，当对数组或集合中的元素进行排序时，会使用该元素类实现的Comparable接口的排序规则。

基本原理：

compareTo与compare方法返回的数值在排序过程中用于确定元素的相对顺序。

具体来说，返回的数值表示两个元素之间的比较结果，通过比较结果，排序算法可以根据特定的规则将元素按照升序或降序排列，以满足排序的目标需求。

总结

Comparable接口是在类本身中定义的，用于提供对象的默认比较规则；

而Comparator接口是一个独立的比较器类，可以在多个地方使用，用于提供定制的比较规则。

使用Comparable接口时，对象按照其自然顺序进行排序；

使用Comparator接口时，可以根据需要提供多个不同的比较规则。