排序是编程中的一项基本操作，在 Java 中，内置的排序方法提供了对基本数据类型和数组进行排序方式，使得管理和操作数据集合变得容易。例如，可以使用Arrays.sort()和Collections.sort()等方法快速对整数数组或字符串列表进行排序。
然而，当涉及到对自定义对象进行排序时，内置的排序方法就显得不足了。这些方法不知道如何根据自定义标准对对象进行排序。这就是 Java 的Comparable和Comparator接口发挥作用的地方，它们允许开发人员定义和实现适合特定需求的自定义排序逻辑。
在这篇文章中，我们将探讨如何使用Comparable和Comparator接口在 Java 中对自定义对象进行排序。我将提供示例来说明每种方法的区别和用例，帮助你掌握 Java 应用程序中的自定义排序。
基本类型的排序方法
Java 提供了多种内置排序方法，使基本数据类型的排序变得容易。这些方法经过高度优化排序效率非常高效，用最少的代码对数组和集合进行排序。对于数组元素是基本类型，如整数、浮点数和字符，通常使用Arrays.sort()方法。
如何使用Arrays.sort()方法
Arrays.sort()方法将指定的数组按升序数值顺序排序。该方法使用快速排序算法。让我们看一个使用Arrays.sort()对整数数组和字符数组进行排序的示例：
package tutorial;
import java.util.Arrays;
public class PrimitiveSorting {
public static void main(String[] args) {
int[] numbers = {5, 3, 8, 2, 1};
System.out.println("原始数组：" + Arrays.toString(numbers));
Arrays.sort(numbers);
System.out.println("排序后的数组：" + Arrays.toString(numbers));
char[] characters = {'o', 'i', 'e', 'u', 'a'};
System.out.println("原始数组：" + Arrays.toString(characters));
Arrays.sort(characters);
System.out.println("排序后的数组：" + Arrays.toString(characters));
}
}输出：
原始数组: [5, 3, 8, 2, 1]
排序后的数组: [1, 2, 3, 5, 8]
原始数组: [o, i, e, u, a]
排序后的数组: [a, e, i, o, u]如何使用Collections.sort()方法
Collections.sort()方法用于对ArrayList等集合进行排序。此方法也基于元素的自然顺序或自定义比较器。
package tutorial;
import java.util.ArrayList;
import java.util.Collections;
public class CollectionsSorting {
public static void main(String[] args) {
ArrayList<String> wordsList = new ArrayList<>();
wordsList.add("banana");
wordsList.add("apple");
wordsList.add("cherry");
wordsList.add("date");
System.out.println("原始列表：" + wordsList);
Collections.sort(wordsList);
System.out.println("排序后的列表：" + wordsList);
}
}输出：
原始列表: [banana, apple, cherry, date]
排序后的列表: [apple, banana, cherry, date]自定义类的限制
虽然 Java 的内置排序方法（如Arrays.sort()和Collections.sort()）对于基本类型和具有自然顺序的对象（如String）进行排序，但在对自定义对象进行排序时却存在不足。这些方法本身不知道如何对用户定义的对象进行排序，因为没有方式来比较这些对象。
例如，考虑一个简单的Person类，它具有name、age和weight属性：
package tutorial;
public class Person {
String name;
int age;
double weight;
public Person(String name, int age, double weight) {
this.name = name;
this.age = age;
this.weight = weight;
}
@Override
public String toString() {
return "person[name=" + name + ",age=" + age + ",weight=" + weight + " kgs]";
}
}如果我们尝试使用Arrays.sort()或Collections.sort()对Person对象列表进行排序，将会遇到编译错误，因为这些方法不知道如何比较Person对象：
package tutorial;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
public class CustomClassSorting {
public static void main(String[] args) {
List<Person> people = new ArrayList<>(Arrays.asList(
new Person("Alice", 30, 65.5),
new Person("Bob", 25, 75.0),
new Person("Charlie", 35, 80.0)
));
System.out.println("原始人员列表：" + people);
Collections.sort(people);
System.out.println("排序后的人员列表：" + people);
}
}编译错误：
java: no suitable method found for sort(java.util.List<tutorial.Person>)
method java.util.Collections.<T>sort(java.util.List<T>) is not applicable
(inference variable T has incompatible bounds
equality constraints: tutorial.Person
lower bounds: java.lang.Comparable<? super T>)
method java.util.Collections.<T>sort(java.util.List<T>,java.util.Comparator<? super T>) is not applicable
(cannot infer type-variable(s) T
(actual and formal argument lists differ in length))错误的原因是Person类没有实现Comparable接口，排序方法无法知道如何比较两个Person对象。
要对像Person这样的自定义对象进行排序，我们需要提供一种比较这些对象的方式。Java 提供了两种主要方法来实现这一点：
- 实现Comparable接口：这允许一个类通过实现compareTo方法来定义其顺序。
- 使用Comparator接口：这允许我们创建单独的类或 lambda 表达式来定义比较对象的方式。
我们将在接下来的部分中探讨这两种方法，首先从Comparable接口开始。
Comparable接口
Java 提供了Comparable接口来为用户定义类的对象定义排序顺序。Comparable接口包含一个方法compareTo()，该方法用于比较当前对象与指定对象的顺序。该方法返回：
- 一个负整数，如果当前对象小于指定对象。
- 零，如果当前对象等于指定对象。
- 一个正整数，如果当前对象大于指定对象。
通过实现Comparable接口，一个类可以确保其对象具有自然顺序。这允许使用Arrays.sort()或Collections.sort()等方法对对象进行排序。
让我们在一个新的PersonV2类中实现Comparable接口，按年龄进行比较。
package tutorial;
public class PersonV2 implements Comparable<PersonV2> {
String name;
int age;
double weight;
public PersonV2(String name, int age, double weight) {
this.name = name;
this.age = age;
this.weight = weight;
}
@Override
public String toString() {
return "PersonV2 [name=" + name + ", age=" + age + ", weight=" + weight + " kgs]";
}
@Override
public int compareTo(PersonV2 other) {
return this.age - other.age;
}
}在这个实现中，compareTo()方法通过将一个年龄减去另一个年龄来比较当前PersonV2对象的age属性与指定PersonV2对象的age属性。通过使用表达式this.age - other.age，我们有效地实现了以下逻辑：
- 如果this.age小于other.age，结果将为负。
- 如果this.age等于other.age，结果将为零。
- 如果this.age大于other.age，结果将为正。
注意：我们也可以使用Integer.compare(this.age, other.age)。
现在PersonV2类实现了Comparable接口，我们可以使用Collections.sort()对PersonV2对象列表进行排序：
package tutorial;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
public class CustomClassSortingV2 {
public static void main(String[] args) {
List<PersonV2> people = new ArrayList<>(Arrays.asList(
new PersonV2("Alice", 30, 65.5),
new PersonV2("Bob", 25, 75.0),
new PersonV2("Charlie", 35, 80.0)
));
System.out.println("原始人员列表：" + people);
Collections.sort(people);
System.out.println("排序后的人员列表：" + people);
}
}输出：
原始人员列表: [PersonV2 [name=Alice, age=30, weight=65.5 kgs], PersonV2 [name=Bob, age=25, weight=75.0 kgs], PersonV2 [name=Charlie, age=35, weight=80.0 kgs]]
排序后的人员列表: [PersonV2 [name=Bob, age=25, weight=75.0 kgs], PersonV2 [name=Alice, age=30, weight=65.5 kgs], PersonV2 [name=Charlie, age=35, weight=80.0 kgs]]在这个示例中，PersonV2对象使用Collections.sort()方法按年龄升序排序，该方法依赖于PersonV2类中compareTo()方法定义的顺序。
Comparable的限制
虽然Comparable接口提供了一种为对象定义顺序的方法，但它有几个限制，可能会限制其在实际应用中的使用。了解这些限制可以帮助我们确定何时使用其他机制（如Comparator接口）来实现更灵活的排序。
- 侵入性- 实现Comparable接口会使比较逻辑与类紧密耦合。如Person类按age比较，若要改变比较方式（如按weight），就得修改类中的compareTo方法，这可能影响其他部分，且不符合解耦原则。
- 比较逻辑单一性- 一个类实现Comparable接口只能定义一种比较方式。像String类按字典序比较，若想按长度比较就无法直接用Comparable实现。在复杂业务中，多种比较需求难以满足。
- 无法跨类比较-Comparable接口的比较方法定义在类内部，不能直接用于不相关类的比较，在跨类排序场景会很不便。
这就是Comparator接口发挥作用的地方。为了定义多种比较对象的方式，我们可以使用Comparator接口，我们将在下一节中探讨它。
Comparator接口
Java 中的Comparator接口提供了一种定义多种比较和排序对象的方式。与Comparable接口不同，Comparator接口允许有多种排序方式，它旨在通过定义多个排序策略来提供灵活性。这使得它在需要以不同方式对对象进行排序的场景中特别有用。
Comparator接口定义了一个方法compare()，该方法比较两个对象并返回：
- 一个负整数，如果第一个对象小于第二个对象。
- 零，如果第一个对象等于第二个对象。
- 一个正整数，如果第一个对象大于第二个对象。
此方法提供了一种为对象定义自定义顺序的方式，而无需修改类本身。
如何使用多种排序方式
Comparator接口允许你创建多个Comparator实例，每个实例定义对象的不同排序方式。这种灵活性意味着你可以根据各种属性或不同顺序对对象进行排序，而无需更改类。
让我们为Person类实现多个Comparator实例。我们将定义按姓名、年龄和体重排序的比较器。首先，我们需要为Person类添加 getter 方法，方便对属性的访问。
package tutorial;
public class Person {
String name;
int age;
double weight;
public Person(String name, int age, double weight) {
this.name = name;
this.age = age;
this.weight = weight;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public double getWeight() {
return weight;
}
@Override
public String toString() {
return "Person [name=" + name + ", age=" + age + ", weight=" + weight + " kgs]";
}
}按姓名比较
此比较器按Person对象的姓名按字母顺序对其进行排序。
package tutorial.comparator;
import tutorial.Person;
import java.util.Comparator;
public class PersonNameComparator implements Comparator<Person> {
@Override
public int compare(Person p1, Person p2) {
return p1.getName().compareTo(p2.getName());
}
}按年龄比较
此比较器按Person对象的年龄升序对其进行排序。
package tutorial.comparator;
import tutorial.Person;
import java.util.Comparator;
public class PersonAgeComparator implements Comparator<Person> {
@Override
public int compare(Person p1, Person p2) {
return p1.getAge() - p2.getAge();
}
}按体重比较
此比较器按Person对象的体重升序对其进行排序。
package tutorial.comparator;
import tutorial.Person;
import java.util.Comparator;
public class PersonWeightComparator implements Comparator<Person> {
@Override
public int compare(Person p1, Person p2) {
return (int) (p1.getWeight() - p2.getWeight());
}
}以下是如何使用这些Comparator实例对Person对象列表进行排序：
package tutorial;
import tutorial.comparator.PersonAgeComparator;
import tutorial.comparator.PersonNameComparator;
import tutorial.comparator.PersonWeightComparator;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.List;
public class CustomClassSortingV3 {
public static void main(String[] args) {
List<Person> people = new ArrayList<>(Arrays.asList(
new Person("Alice", 30, 65.5),
new Person("Bob", 25, 75.0),
new Person("Charlie", 35, 80.0)
));
System.out.println("原始人员列表：" + people);
Collections.sort(people, new PersonNameComparator());
System.out.println("按姓名排序后的人员列表：" + people);
Collections.sort(people, new PersonAgeComparator());
System.out.println("按年龄排序后的人员列表：" + people);
Collections.sort(people, new PersonWeightComparator());
System.out.println("按体重排序后的人员列表：" + people);
}
}输出：
原始人员列表: [Person [name=Alice, age=30, weight=65.5 kgs], Person [name=Bob, age=25, weight=75.0 kgs], Person [name=Charlie, age=35, weight=80.0 kgs]]
按姓名排序后的人员列表: [Person [name=Alice, age=30, weight=65.5 kgs], Person [name=Bob, age=25, weight=75.0 kgs], Person [name=Charlie, age=35, weight=80.0 kgs]]
按年龄排序后的人员列表: [Person [name=Bob, age=25, weight=75.0 kgs], Person [name=Alice, age=30, weight=65.5 kgs], Person [name=Charlie, age=35, weight=80.0 kgs]]
按体重排序后的人员列表: [Person [name=Alice, age=30, weight=65.5 kgs], Person [name=Bob, age=25, weight=75.0 kgs], Person [name=Charlie, age=35, weight=80.0 kgs]]在这个示例中，Comparator实例允许根据不同的属性（姓名、年龄和体重）对Person对象进行排序。
Comparable与Comparator
在 Java 中对对象进行排序时，你有两个主要选择：Comparable和Comparator接口。理解这两个接口之间的差异可以帮助你根据需要选择正确的方法。请注意，这也是一个非常重要的面试问题。
以下是对 Java 中Comparable和Comparator接口的对比：
特性 |
|
|
定义 | 为对象提供单一的自然顺序 | 提供多种比较对象的方式 |
方法 |
|
|
实现 | 在类本身内部实现 | 在类外部实现 |
排序标准 | 一种默认的自然顺序 | 多种排序标准 |
灵活性 | 限于一种比较对象的方式 | 灵活；可以定义多个比较器 |
类修改 | 需要修改类以实现 | 不需要修改类 |
用例 | 当有明确的自然顺序时使用（例如，按员工 ID 排序） | 当需要不同的排序顺序或无法修改类时使用 |
优缺点
Comparable 接口
- 优点:定义自然排序规则，简单自然，与类紧密结合。保证排序规则的一致性。
- 缺点:排序规则和类耦合，修改规则可能影响现有代码。无法对未实现该接口的类直接排序。
Comparator 接口
- 优点:灵活性高，可定义多种排序规则，无需修改原始类。能对无法修改源代码的类定义排序规则。
- 缺点:代码相对复杂，特别是定义多个比较器时。性能稍差，每次排序都要调用compare方法。
总之，能修改类且排序规则固定、与类语义紧密相关，选择Comparable接口；不能修改类，就用Comparator接口。只需一种排序规则（类的自然属性），用Comparable；需要多种排序规则，选Comparator。性能敏感且排序规则简单固定，考虑Comparable；代码简洁性优先且规则不复杂，Comparable较合适，但复杂的多种排序规则用Comparator更好。
总结
掌握Comparable和Comparator接口的使用，能够显著提升你在 Java 中处理对象集合时进行排序操作的能力。这两个接口为你提供了强大的工具，使你能够根据不同的需求灵活地对自定义对象进行排序。
为了加深对这两个接口的理解，建议你在实际的编程场景中积极尝试实现它们。通过实践，你将更加深入地体会它们各自的优势和适用场景，从而能够更加准确地选择合适的接口来满足具体的排序需求，提升程序的效率和可读性。
