Java高手必備：Comparable與Comparator接口深度解析
排序是編程中的一項基本操作，在 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 中處理對象集合時進行排序操作的能力。這兩個接口為你提供了強大的工具，使你能夠根據不同的需求靈活地對自定義對象進行排序。
為了加深對這兩個接口的理解，建議你在實際的編程場景中積極嘗試實現它們。通過實踐，你將更加深入地體會它們各自的優勢和適用場景，從而能夠更加準確地選擇合適的接口來滿足具體的排序需求，提升程序的效率和可讀性。
