在 Java 中，对象排序主要通过两种接口实现：自然排序（Comparable） 和 定制排序（Comparator）。它们分别适用于不同的场景，下面详细对比和说明。

• 自然排序：java.lang.Comparable
• 定制排序：java.util.Comparator

---

一、自然排序：java.lang.Comparable<T>

✅ 适用场景

• 对象有明确的、唯一的默认排序规则（如数字大小、字母顺序、按 ID 升序等）。
• 排序逻辑是类本身固有属性的一部分。

🔧 使用方式

让类实现 Comparable<T> 接口，并重写 compareTo(T o) 方法。

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

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

    // 自然排序：按年龄升序
    @Override
    public int compareTo(Student other) {
        return Integer.compare(this.age, other.age);
    }

    @Override
    public String toString() {
        return name + "(" + age + ")";
    }
}

📌 使用示例

List<Student> students = Arrays.asList(
    new Student("Alice", 20),
    new Student("Bob", 18),
    new Student("Charlie", 22)
);

Collections.sort(students); // 或 students.sort(null);
System.out.println(students); 
// 输出: [Bob(18), Alice(20), Charlie(22)]

💡 TreeSet、TreeMap 等有序集合默认使用自然排序（若未提供 Comparator）。

---

二、定制排序：java.util.Comparator<T>

✅ 适用场景

• 需要多种排序方式（如按姓名、按年龄降序、按成绩等）；
• 不能修改原始类（如第三方类、JDK 类）；
• 排序逻辑不属于对象本身职责。

🔧 使用方式

实现 Comparator<T> 接口（通常用 Lambda 或方法引用）。

// 按姓名排序
Comparator<Student> byName = (s1, s2) -> s1.getName().compareTo(s2.getName());

// 按年龄降序
Comparator<Student> byAgeDesc = (s1, s2) -> Integer.compare(s2.getAge(), s1.getAge());

// 多级排序：先按年龄升序，再按姓名升序
Comparator<Student> byAgeThenName = 
    Comparator.comparing(Student::getAge)
              .thenComparing(Student::getName);

📌 使用示例

List<Student> students = ...;

// 方式1：传入 Comparator
students.sort(byName);

// 方式2：直接使用 Lambda
students.sort((s1, s2) -> s1.getName().compareTo(s2.getName()));

// 方式3：使用 Collections.sort
Collections.sort(students, byAgeDesc);

⚙️ 常用静态方法（Java 8+）

Comparator.comparing(Student::getAge)               // 按年龄升序
Comparator.comparing(Student::getName).reversed()   // 按姓名降序
Comparator.comparingInt(Student::getAge)            // 避免装箱（性能更好）

---

三、核心区别对比

特性	Comparable（自然排序）	Comparator（定制排序）
定义位置	写在被排序类内部	外部独立定义（可多个）
修改权限	需要能修改源码	无需修改源码（适合第三方类）
排序数量	只能有一种“自然”顺序	可定义任意多种排序规则
调用方式	list.sort(null) 或 Collections.sort(list)	list.sort(comparator)
语义	“我能和同类比较”	“我来帮你比较两个对象”
典型应用	Integer, String, Date 等 JDK 类	业务自定义排序、多维度排序

---

四、实际开发建议

1. 优先考虑 Comparable
   如果对象有明确的、通用的排序规则（如用户 ID、时间戳），实现 Comparable 更直观。

2. 复杂/多变排序用 Comparator
   如报表需要按不同字段排序，或临时按某种规则筛选，使用 Comparator 更灵活。

3. 避免同时滥用两者
   若一个类既有 compareTo 又频繁使用外部 Comparator，需确保逻辑不冲突。

4. 注意空值处理
   使用 Comparator.nullsFirst() / nullsLast() 避免 NPE：

   Comparator<Student> safeByName = 
       Comparator.nullsLast(Comparator.comparing(Student::getName));
   

5. 性能提示

   • comparingInt / comparingLong 比 comparing 更高效（避免自动装箱）；
   • 复杂对象提取 key 时，可缓存计算结果。

---

五、完整示例：多排序策略

List<Student> list = Arrays.asList(
    new Student("Tom", 20),
    new Student("Jerry", 19),
    new Student("Alice", 20)
);

// 自然排序（按年龄）
list.sort(null); 

// 按姓名
list.sort(Comparator.comparing(Student::getName));

// 年龄降序 + 姓名升序
list.sort(
    Comparator.comparing(Student::getAge, Comparator.reverseOrder())
              .thenComparing(Student::getName)
);

---

总结

• Comparable = “我是怎么排的” → 定义对象的内在排序规则。
• Comparator = “你想怎么排我” → 提供外部、灵活的排序策略。

合理结合两者，可写出清晰、高效、可维护的排序逻辑。在现代 Java（8+）中，Comparator 的链式 API 极大提升了可读性和表达力，推荐熟练掌握。