对集合元素排序比较

1.使用 Comparable 接口实现默认排序

Comparable 是 Java 中的一个接口，用于定义对象之间的排序规则。

实现了 Comparable 接口的类可以比较其对象的大小（包装类都实现了该接口），从而可以在集合类（如 TreeSet、TreeMap 等）中进行排序和查找操作。这种排序被称为类的自然排序，类的 compareTo() 方法被称为它的自然比较方法。

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

compareTo() 方法的返回值有以下三种情况：

• 返回负整数：表示当前对象小于传入对象。
• 返回零：表示当前对象等于传入对象。
• 返回正整数：表示当前对象大于传入对象。
• T 是泛型的一种表现方式，表示一种类型。

示例：

实现了comparable接口，重写了 compareTo() 方法,通过比较年龄、成绩、名字实现自身和对象之间的比较。

public class CompareTo {
    public static void main(String[] args) {
        Students[] students = {
                new Students("张三", 23, 90.0),
                new Students("李四", 24, 80.5),
                new Students("王五", 23, 70.8),
                new Students("赵六", 24, 80.5),
                new Students("田七", 25, 50.9)
        };
        sort(students);
        //遍历
        for (Students stud : students) {
            System.out.println(stud);
        }
    }

    public static void sort(Students[] students){
        for(int i = 0;i < students.length-1;i++){
            for(int j =0; j < students.length-1-i;j++){
                if(students[j].compareTo(students[j+1]) > 0){
                    Students temp = students[j+1];
                    students[j+1] = students[j];
                    students[j] = temp;

                }
            }

        }
    }

}
class Students implements Comparable,Cloneable{
    private String name;
    private int age;
    private Double score;
    public Students(){
        super();
    }

    public Students(String name, int age, Double score) {
        this.name = name;
        this.age = age;
        this.score = score;
    }
    /**
     重写比较器
     */
    /**
     * @param o the object to be compared.
     * @return
     */
    @Override
    public int compareTo(Object o) {
        if(o instanceof Students students){
            if(this.age > students.age){
                return 1;
            } else if (this.age < students.age) {
                return -1;
            }
            if (this.score < students.score) {
                return -1;
            } else if (this.score > students.score) {
                return -1;
            }
            return this.name.compareTo(students.name);
        }
       throw new CompareToException("类型不匹配");
    }

    public String toString(){
        return "Student [name=" + name + ", age=" + age + ", score=" + score + "]";

    }

}
/**
  自定义异常
 */
class CompareToException extends RuntimeException{
    public CompareToException(){
        super();
    }
    public CompareToException(String message) {
        super(message);
    }
}

输出：

Student [name=张三, age=23, score=90.0]
Student [name=王五, age=23, score=70.8]
Student [name=李四, age=24, score=80.5]
Student [name=赵六, age=24, score=80.5]
Student [name=田七, age=25, score=50.9]

2. 使用 Comparator 接口实现比较器排序

Comparator 是 java 中的一个接口，用于定义对象之间的定制排序规则。

与 Comparable 接口不同，Comparator 接口允许在排序时使用独立于对象类的比较逻辑，因此可以在不休改对象类的情况下实现多种不同的排序方式，当使用了实现 Comparator 接口的比较器后，默认的 COmparable 比较器就不起作用了。

使用 Comparator 接口需要重写 compare() 方法，该方法的定义语法格式如下：

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

按照薪资排序

import java.util.Arrays;
import java.util.Comparator;

public class Compare {
    public static void main(String[] args) {
        Person[] person = {
                new Person("张三",22,4563.9),
                new Person("李四",35,13542.9),
                new Person("王五",22,8756.9),
                new Person("赵六",28,23523.6),

        };
        // 使用 Arrsys.sort(),传入比较器，实现对多个对象比较
        PersonComparator comparator = new PersonComparator();
        Arrays.sort(person, comparator);
        for (Person per : person) {
            System.out.println(per.toString());
        }

        // 比较两个对象
//        int n = Objects.compare(stus[1], stus[3], comparator);
//        System.out.println(n);
    }
    }
class Person{
    private String name;
    private int age;
    private Double sar;

    public Person(String name, int age, Double sar) {
        this.name = name;
        this.age = age;
        this.sar = sar;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
    public Double getSar() {
        return sar;
    }

    public void setSar(Double sar) {
        this.sar = sar;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", sar=" + sar +
                '}';
    }
}
class PersonComparator implements Comparator{
    /**
     比较器
     */
    @Override
    public int compare(Object o1, Object o2) {
        if(o1 != null && o2 != null){
            if(o1 instanceof Person person && o2 instanceof Person person1){
                if(person.getSar() > person1.getSar()){
                    return 1;
                } else if (person.getSar() <  person1.getSar()) {
                    return -1;
                }
                return person.getName().compareTo(person1.getName());
            }
        }
        throw new CompareException("输入类型异常");
    }
}
/**
     自定义异常
     */
class CompareException extends RuntimeException{
    public CompareException(){
        super();
    }
    public CompareException(String message) {

        super(message);
    }
}

输出：

Person{name='张三', age=22, sar=4563.9}
Person{name='王五', age=22, sar=8756.9}
Person{name='李四', age=35, sar=13542.9}
Person{name='赵六', age=28, sar=23523.6}

compare() 方法用于在 Arrays 类调用 sort(比较对象数组, 比较器) 方法时，对两个对象进行比较大小。