介紹

有時在做項目時需要對某種類型的對象集合進行排序，為此你可能會認為有必要實現(xiàn)我們自己的排序算法，但這有點不必要，盡管了解一下也沒什么壞處他們如何工作。例如，如果您有一個整數(shù)數(shù)組，則可以使用 Arrays.sort() 方法，該方法接受基元數(shù)組并按升序對其進行排序，從而利用無需將結果分配給新變量，因為該方法修改了原始數(shù)組。

int[] numbers = {9, 8, 5, 3, 1, 2, 4, 6, 7};
Arrays.sort(numbers);
System.out.println(Arrays.toString(numbers));

// Output
[1, 2, 3, 4, 5, 6, 7, 8, 9]

當您有自定義對象的集合（例如 Movie 類型的記錄）時，這也適用，但如果我們看到 Arrays.sort() 方法，它不接受這種類型的對象數(shù)組，因此它必須使用 sort() 方法接受 T 類型的對象和 Comparator 類型的對象作為參數(shù)超級T>這是一個函數(shù)式接口。這個接口非常重要，因為 Java 中的許多其他方法都使用它以自定義方式比較對象。例如，List 對象的 Collections.sort() 方法或 sort() 方法，甚至 Streams 也接受 Comparator 來對元素進行排序。

什么是比較器？

函數(shù)式接口Comparator（函數(shù)式它可以寫成lambda表達式）是一個允許你比較兩個T類型對象的接口，因此它用于比較整數(shù)、字符串、自定義物體等該接口有幾個靜態(tài)和默認方法，但重要的是compare() 方法，它是比較兩個對象必須實現(xiàn)的方法。 Compare() 接收兩個 T 類型的對象并返回一個整數(shù)。方法簽名如下：

int compare(T o1, T o2);

如果o1小于o2，該方法返回負數(shù)；如果相等，則返回零；如果o1大于o2，該方法返回正數(shù)，通常分別返回-1、0或1。

一個對象小于、等于或大于另一個對象意味著什么？

讓我們分析一下compare()方法返回的內容，因為對象的排序取決于此，重要的是要考慮該方法返回的含義是相對的，也就是說，如果您想要升序或降序排列。這取決于具體情況以及如何實施。讓我們?yōu)槊總€示例考慮以下記錄：

int[] numbers = {9, 8, 5, 3, 1, 2, 4, 6, 7};
Arrays.sort(numbers);
System.out.println(Arrays.toString(numbers));

// Output
[1, 2, 3, 4, 5, 6, 7, 8, 9]

• 如果第一個參數(shù)小于第二個參數(shù)，則返回負數(shù)。例如，要按發(fā)行年份對電影進行排序，當電影 a 小于電影 b 時，可以返回 -1：

int compare(T o1, T o2);

• 如果第一個參數(shù)大于第二個參數(shù)，則返回正數(shù)。例如，要按預算對電影進行排序，當電影 a 大于電影 b 時，可以返回 1：

public record Movie(
        String name,
        List<String> actors,
        int budget,
        int year
) {
}

• 如果第一個參數(shù)等于第二個參數(shù)，則返回零。例如，要按演員數(shù)量對電影進行排序，當電影 a 等于電影 b 時，可以返回 0：

// a < b -> -1
a.year() < b.year() -> -1

使用比較器

假設我們在 List 類型的對象中有以下電影：

// a > b -> 1
a.budget() > b.budget() -> 1

如果您想按發(fā)行年份升序排列電影，您可以創(chuàng)建一個 Comparator 類型的對象并重寫compare()方法，然后將此對象傳遞給列表的sort()方法：

// a == b -> 0
a.actors().size() == b.actors().size() -> 0

它也可以在 sort() 方法中實現(xiàn)為匿名類：

Movie movie1 = new Movie("The Godfather", Arrays.asList("Marlon Brando", "Al Pacino"), 6000000, 1972);
Movie movie2 = new Movie("The Godfather: Part II", Arrays.asList("Al Pacino", "Robert De Niro"), 13000000, 1974);
Movie movie3 = new Movie("The Shawshank Redemption", Arrays.asList("Tim Robbins", "Morgan Freeman"), 25000000, 1994);
Movie movie4 = new Movie("The Dark Knight", Arrays.asList("Christian Bale", "Heath Ledger"), 185000000, 2008);

List<Movie> movies = Arrays.asList(movie1, movie2, movie3, movie4);

或者更簡潔地直接在 sort() 方法中使用 lambda 表達式：

Comparator<Movie> comparatorByYear = new Comparator<Movie>() {
    @Override
    public int compare(Movie o1, Movie o2) {
        return o1.year() - o2.year();
    }
};

movies.sort(comparatorByYear);

任何這些實現(xiàn)??都會按發(fā)布年份對列表進行升序排序。如果要按降序排序，可以更改 lambda 表達式中參數(shù)的順序，或者在減法中添加負號：

movies.sort(new Comparator<Movie>() {
    @Override
    public int compare(Movie o1, Movie o2) {
        return o1.year() - o2.year();
    }
});

如何對自定義對象列表進行排序的一些其他示例是：

• 按演員數(shù)量升序排列電影（從少到多）：

movies.sort((p1, p2) -> p1.year() - p2.year());

• 按預算降序對電影進行排序（從最高預算到最低預算）：

movies.sort((p1, p2) -> p2.year() - p1.year());
// o
movies.sort((p1, p2) -> - (p1.year() - p2.year()));

• 按名稱升序對電影進行排序：

movies.sort((p1, p2) -> p1.actors().size() - p2.actors().size());

在其他示例中，我們可能會遇到需要按降序對整數(shù)列表進行排序的情況，

movies.sort((p1, p2) -> p2.budget() - p1.budget());
// o 
movies.sort((p1, p2) -> - (p1.budget() - p2.budget()));

為此，您還可以使用靜態(tài)方法 Comparator.reverseOrder() 返回一個按降序對元素進行排序的比較器，以及使用 Comparator.naturalOrder() 按升序對元素進行排序。

int[] numbers = {9, 8, 5, 3, 1, 2, 4, 6, 7};
Arrays.sort(numbers);
System.out.println(Arrays.toString(numbers));

// Output
[1, 2, 3, 4, 5, 6, 7, 8, 9]

使用 Integer.compare()

在 Java 中已經(jīng)有一些方法允許我們以有效的方式執(zhí)行這種類型的比較，例如 Integer.compare() ，它比較兩個整數(shù)，如果第一個參數(shù)小于第二個參數(shù)零，則返回負數(shù)如果第一個參數(shù)大于第二個參數(shù)，則相等且為正數(shù)。如果我們分析這個方法的工作原理，我們可以看到它與上面解釋的類似，并且返回的正是Comparator接口的compare()方法所需要的。 Integer.compare() 的實現(xiàn)如下：

int compare(T o1, T o2);

因此，如果您想按發(fā)行年份升序對電影進行排序，可以使用 Integer.compare():

public record Movie(
        String name,
        List<String> actors,
        int budget,
        int year
) {
}

使用參考方法

有時可以使用引用方法來執(zhí)行與以前不同的比較，例如，按升序對整數(shù)列表進行排序：

// a < b -> -1
a.year() < b.year() -> -1

Integer 不是唯一具有compareTo() 方法的類，例如 String 有一個compareTo() 方法，可以按字典順序比較兩個字符串，因此它可以用于對字符串列表進行排序，甚至可以將 CharSequence 與其一起使用Compare() 方法（技術上表示字符序列）。

// a > b -> 1
a.budget() > b.budget() -> 1

回到電影的例子，如果你想按照上映年份升序對電影進行排序，可以使用compareingInt()方法作為參考方法：

// a == b -> 0
a.actors().size() == b.actors().size() -> 0

或者根據(jù) String 類型屬性進行比較，在本例中為電影名稱：

Movie movie1 = new Movie("The Godfather", Arrays.asList("Marlon Brando", "Al Pacino"), 6000000, 1972);
Movie movie2 = new Movie("The Godfather: Part II", Arrays.asList("Al Pacino", "Robert De Niro"), 13000000, 1974);
Movie movie3 = new Movie("The Shawshank Redemption", Arrays.asList("Tim Robbins", "Morgan Freeman"), 25000000, 1994);
Movie movie4 = new Movie("The Dark Knight", Arrays.asList("Christian Bale", "Heath Ledger"), 185000000, 2008);

List<Movie> movies = Arrays.asList(movie1, movie2, movie3, movie4);

按多個屬性排序

有時你可能需要按多個屬性對對象列表進行排序，例如，如果你想按發(fā)行年份升序對電影進行排序，按預算降序排序，你可以使用 thenComparing() 方法，該方法接收一個比較器，負責按多個屬性排序。例如，如果有兩部電影a和b，上映年份相同，則按預算排序。

Comparator<Movie> comparatorByYear = new Comparator<Movie>() {
    @Override
    public int compare(Movie o1, Movie o2) {
        return o1.year() - o2.year();
    }
};

movies.sort(comparatorByYear);

結論

比較器在Java中很多時候都很有用，因為它們可以讓你以個性化的方式比較對象，不僅如此，它們還可以用在許多Java集合方法中，甚至可以有多個比較器來排序以不同的方式。無論哪種方式，您都可以查閱 IDE 中的 Comparator 文檔或官方 Java 文檔，了解可以使用哪些方法以及如何實現(xiàn)它們。

以上是Java 中的比較器是如何工作的？的詳細內容。更多信息請關注PHP中文網(wǎng)其他相關文章！