Java中两种比较器

1. Comparable 接口示例：

2. import java.util.ArrayList;
   import java.util.Collections;

   class Student implements Comparable<Student> {
       private int id;
       private String name;

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

       public int getId() {
           return id;
       }

       public String getName() {
           return name;
       }

       @Override
       public int compareTo(Student other) {
           // 按照学生ID进行排序
           return Integer.compare(this.id, other.id);
       }
   }

   public class ComparableExample {
       public static void main(String[] args) {
           ArrayList<Student> students = new ArrayList<>();
           students.add(new Student(3, "Alice"));
           students.add(new Student(2, "Bob"));
           students.add(new Student(1, "Charlie"));

           Collections.sort(students);

           for (Student student : students) {
               System.out.println("ID: " + student.getId() + ", Name: " + student.getName());
           }
       }
   }
   在这个示例中，Student 类实现了 Comparable 接口，并重写了 compareTo() 方法。通过比较学生对象的 ID 来定义排序规则。然后使用 Collections.sort() 对学生列表进行排序，并打印排序结果。

3. Comparator 接口示例：

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

   class Person {
       private String name;
       private int age;

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

       public String getName() {
           return name;
       }

       public int getAge() {
           return age;
       }
   }

   class AgeComparator implements Comparator<Person> {
       @Override
       public int compare(Person person1, Person person2) {
           // 按照年龄进行排序
           return Integer.compare(person1.getAge(), person2.getAge());
       }
   }

   public class ComparatorExample {
       public static void main(String[] args) {
           ArrayList<Person> people = new ArrayList<>();
           people.add(new Person("Alice", 25));
           people.add(new Person("Bob", 20));
           people.add(new Person("Charlie", 30));

           Collections.sort(people, new AgeComparator());

           for (Person person : people) {
               System.out.println("Name: " + person.getName() + ", Age: " + person.getAge());
           }
       }
   }

   在这个示例中，Person 类定义了一个简单的人员对象。然后创建了一个 AgeComparator 类实现了 Comparator 接口，并重写了 compare() 方法。按照人员对象的年龄来定义排序规则。通过传入自定义比较器对象 new AgeComparator() 到 Collections.sort() 来对人员列表进行排序，并打印排序结果。

   这些示例演示了使用 Comparable 接口和 Comparator 接口来定义不同的比较规则，以及如何在 Java 中进行对象的排序

在 Java 中，我们可以使用内部比较器（Internal Comparator）和外部比较器（External Comparator）来进行对象的比较和排序。

内部比较器（Internal Comparator）：

• 内部比较器是指实现了 Comparable 接口的类自身所提供的比较方法。
• Comparable 接口中有一个 compareTo() 方法，用于定义对象之间的自然排序顺序。
• 类实现了 Comparable 接口后，可以通过重写 compareTo() 方法来定义对象的比较逻辑。
• 内部比较器通常用于对类的实例进行默认排序，例如使用 Collections.sort() 方法进行排序。

外部比较器（External Comparator）：

• 外部比较器是指独立于被比较的类之外的一个实现了 Comparator 接口的类。
• Comparator 接口定义了 compare() 方法，用于比较两个对象的大小关系。
• 外部比较器不依赖于比较对象的类的实现，而是在独立的比较器类中定义了比较逻辑。
• 使用外部比较器可以对同一类的对象进行不同的比较方式，或者对不可修改的类进行排序。

import java.util.*;

// 内部比较器示例
class Person implements Comparable<Person> {
    private String name;
    private int age;

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

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    @Override
    public int compareTo(Person person) {
        return this.age - person.getAge(); // 按年龄升序排序
    }
}

// 外部比较器示例
class NameComparator implements Comparator<Person> {
    @Override
    public int compare(Person p1, Person p2) {
        return p1.getName().compareTo(p2.getName()); // 按姓名升序排序
    }
}

public class Example {
    public static void main(String[] args) {
        List<Person> list = new ArrayList<>();
        list.add(new Person("John", 25));
        list.add(new Person("Alice", 30));
        list.add(new Person("Bob", 20));

        // 使用内部比较器进行排序
        Collections.sort(list);
        System.out.println("按年龄排序：" + list);

        // 使用外部比较器进行排序
        Collections.sort(list, new NameComparator());
        System.out.println("按姓名排序：" + list);
    }
}

在上述示例中，Person 类实现了 Comparable 接口，并重写了 compareTo() 方法，用于按照年龄排序。然后，我们可以使用 Collections.sort() 方法对 List<Person> 进行排序。另外，NameComparator 类实现了 Comparator 接口，并重写了 compare() 方法，用于按照姓名排序。同样，我们可以使用该比较器对 List<Person> 进行排序。通过使用内部比较器和外部比较器，我们可以自定义对象的比较方式，以满足不同的排序需求。