ComparableAndCompartor

Comparable:

• Comparable 是一个内部接口，它定义了一个对象自身的比较规则。
• 当一个类实现了 Comparable 接口时，它必须实现 compareTo() 方法，并根据自己的排序规则来定义该方法。
• compareTo() 方法返回一个整数值，表示当前对象与传入的对象的比较结果。如果返回负数，则表示当前对象小于传入的对象；如果返回正数，则表示当前对象大于传入的对象；如果返回零，则表示两个对象相等。
• Comparable 接口常用于实现对象的默认排序（如数组或集合的排序）。

举例：

java
public class Person implements Comparable<Person> {
    private String name;
    private int age;

    // 构造方法和其他方法...

    @Override
    public int compareTo(Person other) {
        return this.age - other.age; // 根据年龄比较
    }
}

Comparator:

• Comparator 是一个外部接口，它用于定义不同于对象自身的比较规则。
• 当需要对某个类的对象进行排序时，可以使用 Comparator 来提供自定义的比较规则。
• Comparator 接口定义了一个 compare() 方法，用于比较两个对象。
• compare() 方法返回一个整数值，表示第一个对象与第二个对象的比较结果。如果返回负数，则表示第一个对象小于第二个对象；如果返回正数，则表示第一个对象大于第二个对象；如果返回零，则表示两个对象相等。
• Comparator 接口常用于实现特定的排序需求，可以在排序时动态指定使用哪个比较规则。

举例：

java
public class PersonComparator implements Comparator<Person> {
    @Override
    public int compare(Person p1, Person p2) {
        return p1.getName().compareTo(p2.getName()); // 根据姓名比较
    }
}

测试类

package com.miao;

import java.util.*;

/**
 * @author 缪广亮
 * @version 1.0
 */
public class ComparableAndComparator {
    public static void main(String[] args) {
        // 创建一组 Person 对象
        Person person1 = new Person("Alice", 25, 165.0);
        Person person2 = new Person("Bob", 30, 170.5);
        Person person3 = new Person("Cathy", 25, 160.0);
        Person person4 = new Person("David", 30, 170.0);
        Person person5 = new Person("Emma", 20, 168.0);

        Person[] persons = {person1, person2, person3, person4, person5};
//        将person加入到集合才能用Collections.sort(persons);
//        Collections.sort(persons);
        // 使用 Comparable 接口的默认排序规则对数组进行排序
        Arrays.sort(persons);
        System.out.println("使用 Comparable 接口的默认排序规则：");
        for (Person person : persons) {
            System.out.println(person);
        }

        // 使用 Comparator 接口的自定义排序规则对数组进行排序
        List<Person> personList = Arrays.asList(persons);//将数组转成list集合
        Collections.sort(personList, new Person.PersonComparator());
        System.out.println("\n使用 Comparator 接口的自定义排序规则：");
        for (Person person : personList) {
            System.out.println(person);
        }
    }

}

class Person implements Comparable<Person> {
    private String name;
    private int age;
    private double height;

    public Person(String name, int age, double height) {
        this.name = name;
        this.age = age;
        this.height = height;
    }
    // 构造方法和其他方法...


    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    public double getHeight() {
        return height;
    }

    public void setHeight(double height) {
        this.height = height;
    }

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

    @Override
    public int compareTo(Person other) {
        if (this.age != other.age) {
            return this.age - other.age; // 根据年龄比较
        } else if (this.height != other.height) {
            return Double.compare(other.height, this.height); // 根据身高比较
        } else {
            return this.name.compareTo(other.name); // 根据姓名比较
        }
    }

    public static class PersonComparator implements Comparator<Person> {
        @Override
        public int compare(Person p1, Person p2) {
            if (p1.getAge() != p2.getAge()) {
                return p1.getAge() - p2.getAge(); // 根据年龄比较
            } else if (p1.getHeight() != p2.getHeight()) {
                return Double.compare(p2.getHeight(), p1.getHeight()); // 根据身高比较
            } else {
                return p1.getName().compareTo(p2.getName()); // 根据姓名比较
            }
        }
    }
}