Java中对对象排序

在Java中，对对象进行排序通常可以通过两种方式实现：一种是使用Comparable接口，另一种是使用Comparator接口。这两种方式各有特点，适用于不同的场景。

一：使用Comparable接口

在Java中，Comparable接口是一个非常重要的接口，它定义了一个对象与其他同类型对象进行比较的规则。当一个类实现了Comparable接口时，这个类的对象就可以被排序了。实现Comparable接口需要重写compareTo方法，该方法定义了对象之间比较的逻辑。

实现步骤

1. 让类实现Comparable接口：首先，你需要在你的类定义中明确地指出这个类实现了Comparable接口，并指定泛型参数为你的类本身（或者你想要与之比较的另一个类，但通常情况下是自身）。

2. 重写compareTo方法：然后，你需要在你的类中重写compareTo方法。这个方法接收一个同类型的对象作为参数，并返回一个整数，表示当前对象与参数对象之间的比较结果。

   • 如果当前对象小于参数对象，则返回一个小于0的整数。
   • 如果当前对象等于参数对象，则返回0。
   • 如果当前对象大于参数对象，则返回一个大于0的整数。

3. 使用排序方法：一旦你的类实现了Comparable接口并正确地重写了compareTo方法，你就可以使用Java集合框架中的Collections.sort()方法（对于集合）或Arrays.sort()方法（对于数组）来对你的对象进行排序了。

示例

假设我们有一个Person类，包含姓名和年龄两个属性，我们想要根据年龄来对Person对象进行排序。

public class Person implements Comparable<Person> {  
    private String name;  
    private int age;  
  
    // 构造函数、getter和setter省略  
  
    // 实现Comparable接口的compareTo方法  
    @Override  
    public int compareTo(Person other) {  
        // 直接使用Integer.compare来比较两个整数，这是Java 7及以上版本推荐的做法  
        return Integer.compare(this.age, other.age); 
 
        // 在Java 7之前，你可能需要这样写：  
        // if (this.age < other.age) return -1;  
        // if (this.age > other.age) return 1;  
        // return 0;  
        或者可以用以下方式
        // return this.age-other.age;
    }  
  
    // 为了完整性，这里提供一个简单的toString方法  
    //如果不重写toString方法，将返回地址
    @Override  
    public String toString() {  
        return "Person{" +  
                "name='" + name + '\'' +  
                ", age=" + age +  
                '}';  
    }  
  
    // 主函数和测试代码  
    public static void main(String[] args) {  
        Person[] people = {  
            new Person("Alice", 30),  
            new Person("Bob", 25),  
            new Person("Charlie", 35)  
        };  
  
        // 使用Arrays.sort方法对Person数组进行排序  
        Arrays.sort(people);  
  
        // 打印排序后的数组  
        for (Person person : people) {  
            System.out.println(person);  
        }  
    }  
}

二：使用Comparator接口

形式：

public static <T> void sort(T[ ] arr，Comparator<? super T> c)

参数一：需要排序的数组

参数二：Comparator比较器对象（用来指定比较器的比较规则）

Comparator它是一个接口，接口能直接有对象么？当然不可以。但是我们可能那接口的匿名内部类对象。

Comparator接口是Java中的一个重要接口，它位于java.util包中，用于定义对象排序的规则。与Comparable接口不同，Comparator接口不是由类本身实现的，而是作为一个单独的比较器传递给排序方法（如Collections.sort()或Arrays.sort()）的。这提供了更大的灵活性，因为你可以为同一个类定义多个不同的排序规则，而不需要修改类的代码。

实现步骤

1. 创建Comparator实现：你可以通过实现Comparator接口来创建一个比较器，或者更简单地，使用Lambda表达式（Java 8及以上版本）来创建匿名函数实例。

2. 实现compare方法：在Comparator的实现中，即制定你所需要的比较规则。你需要定义compare(T o1, T o2)方法，该方法接收两个同类型的对象作为参数，并返回一个整数来表示它们的比较结果。

示例

假设我们有一个Person类，包含姓名和年龄两个属性，我们想要根据年龄或姓名来对Person对象进行排序

import java.util.Arrays;  
import java.util.Comparator;  
  
public class Person {  
    private String name;  
    private int age;  
  
    // 构造函数、getter和setter 
  
    @Override  
    public String toString() {  
        return "Person{" +  
                "name='" + name + '\'' +  
                ", age=" + age +  
                '}';  
    }  
  
    // 主函数和测试代码  
    public static void main(String[] args) {  
        Person[] people = {  
            new Person("Alice", 30),  
            new Person("Bob", 25),  
            new Person("Charlie", 35)  
        };  
  
        // 根据年龄排序 
 
        Arrays.sort(people, Comparator.comparingInt(Person::getAge));  

        // 或者使用匿名内部类（Java 8之前的方式）  
        // Arrays.sort(people, new Comparator<Person>() {  
        //     @Override  
        //     public int compare(Person p1, Person p2) {  
        //         return Integer.compare(p1.getAge(), p2.getAge());  
        //     }  
        // });  
  
        System.out.println("Sorted by age:");  
        for (Person person : people) {  
            System.out.println(person);  
        }  
  
        // 根据姓名排序（忽略大小写） 
 
        Arrays.sort(people, Comparator.comparing(Person::getName, String.CASE_INSENSITIVE_ORDER));  

        // 或者使用Lambda表达式和String的compareToIgnoreCase方法  
        // Arrays.sort(people, (p1, p2) -> p1.getName().compareToIgnoreCase(p2.getName()));  
  
        System.out.println("\nSorted by name (case-insensitive):");  
        for (Person person : people) {  
            System.out.println(person);  
        }  
    }  
  
    
}

补充

当您在Java中使用 System.out.println 或 System.out.print 方法打印一个对象时，如果该对象有 toString 方法（无论是从其类继承的还是重写的），那么这个方法将会被自动调用以获取对象的字符串表示。

这是Java中对象到字符串转换的默认机制。以下是详细解释：

• Object 类定义了一个 toString 方法，它是所有Java类的超类。默认的 toString 方法返回一个字符串，该字符串通常包含类的名称、@ 符号以及对象的哈希码（例如 "java.lang.Object@1f89ab83"）。
• 当您打印一个对象时，System.out.println 和 System.out.print 方法会检查传递给它们的是否是一个对象。
• 如果是对象，它们会调用该对象的 toString 方法。
• 如果您在自定义类中重写了 toString 方法，那么打印对象时将调用您提供的实现，而不是 Object 类的默认实现。

 如果没有在类中重写 toString 方法，那么将调用 Object 类的默认 toString 实现，它通常会返回一个由类名、@ 符号和对象的哈希码值组成的字符串，例如 day3.Student@15db9742。这就是为什么通常建议在自定义类中重写 toString 方法，以便提供更有意义的对象描述。