Java基礎系列-Comparable和Comparator

来源:https://www.cnblogs.com/V1haoge/archive/2019/02/17/10392748.html
-Advertisement-
Play Games

原創文章，轉載請標註出處：[《Java基礎系列 Comparable和Comparator》](https://www.jianshu.com/p/f9870fd05958 一、概述 & 160;& 160;& 160;& 160;& 160;& 160;& 160;& 160;Java中的排序是由 ...


原創文章，轉載請標註出處：《Java基礎系列-Comparable和Comparator》

一、概述

        Java中的排序是由Comparable和Comparator這兩個介面來提供的。

        Comparable表示可被排序的，實現該介面的類的對象自動擁有排序功能。

        Comparator則表示一個比較器，實現了該介面的的類的對象是一個針對目標類的對象定義的比較器，一般情況，這個比較器將作為一個參數進行傳遞。

二、Comparable

        Comparable的中文意思就是可被排序的，代表本身支持排序功能。只要我們的類實現了這個介面，那麼這個類的對象就會自動擁有了可被排序的能力。而且這個排序被稱為類的自然順序。這個類的對象的列表可以被Collections.sort和Arrays.sort來執行排序。同時這個類的實例具備作為sorted map的key和sorted set的元素的資格。

        假如a和b都是實現了Comparable介面的類C的實例，那麼只有當a.compareTo(b)的結果與a.equals(b)的結果一致時，才稱類C的自然順序與equals一致。強烈建議將類的自然順序和equals的結果保持一致，因為如果不一致的話，由該類對象為鍵的sorted map和由該類對象為元素的sorted set的行為將會變得很怪異。

        例如對於一個實現了Comparable介面的元素的有序集合sorted set而言，如果a.equals(b)結果為false，並且a.compareTo(b)==0，則第二個元素的添加操作將會失敗，因為在sorted set看來，二者在排序上是一致的，它不報保存重覆的元素。

        事實上，Java中的類基本都是自然順序與equals一致的，除了BigDecimal，因為BigDecimal中的自然順序和值相同但精度不同的元素（例如4和4.00）的equals均一致。

源碼解析

public interface Comparable<T> {
    public int compareTo(T o);
}

        從源碼中可以看到，該介面只有一個抽象方法compareTo，這個方法主要就是為了定義我們的類所要排序的方式。compareTo方法用於比較當前元素a與指定元素b，結果為int值，如果a > b，int>0；如果a=b，int=0；如果a<b，int<0。

三、Comparator

        Comparator中文譯為比較器，它可以作為一個參數傳遞到Collections.sort和Arrays.sort方法來指定某個類對象的排序方式。同時它也能為sorted set和sorted map指定排序方式。

        同Comparable類似，指定比較器的時候一般也要保證比較的結果與equals結果一致，不一致的話，對應的sorted set和sorted map的行為同樣會變得怪異。

        推薦實現的比較器類同時實現java.io.Serializable介面，以擁有序列化能力，因為它可能會被用作序列化的數據結構（TreeSet、TreeMap）的排序方法。

源碼解析

@FunctionalInterface
public interface Comparator<T> {
    // 唯一的抽象方法，用於定義比較方式（即排序方式）
    // o1>o2，返回1；o1=o2，返回0；o1<o2，返回-1
    int compare(T o1, T o2);
    boolean equals(Object obj);
    // 1.8新增的預設方法：用於反序排列
    default Comparator<T> reversed() {
        return Collections.reverseOrder(this);
    }
    // 1.8新增的預設方法：用於構建一個次級比較器，當前比較器比較結果為0，則使用次級比較器比較
    default Comparator<T> thenComparing(Comparator<? super T> other) {
        Objects.requireNonNull(other);
        return (Comparator<T> & Serializable) (c1, c2) -> {
            int res = compare(c1, c2);
            return (res != 0) ? res : other.compare(c1, c2);
        };
    }
    // 1.8新增預設方法：指定次級比較器的
    // keyExtractor表示鍵提取器，定義提取方式
    // keyComparator表示鍵比較器，定義比較方式
    default <U> Comparator<T> thenComparing(
            Function<? super T, ? extends U> keyExtractor,
            Comparator<? super U> keyComparator)
    {
        return thenComparing(comparing(keyExtractor, keyComparator));
    }
    // 1.8新增預設方法：用於執行鍵的比較，採用的是由鍵對象內置的比較方式
    default <U extends Comparable<? super U>> Comparator<T> thenComparing(
            Function<? super T, ? extends U> keyExtractor)
    {
        return thenComparing(comparing(keyExtractor));
    }
    // 1.8新增預設方法：用於比較執行int類型的鍵的比較
    default Comparator<T> thenComparingInt(ToIntFunction<? super T> keyExtractor) {
        return thenComparing(comparingInt(keyExtractor));
    }
    // 1.8新增預設方法：用於比較執行long類型的鍵的比較
    default Comparator<T> thenComparingLong(ToLongFunction<? super T> keyExtractor) {
        return thenComparing(comparingLong(keyExtractor));
    }
    // 1.8新增預設方法：用於比較執行double類型的鍵的比較
    default Comparator<T> thenComparingDouble(ToDoubleFunction<? super T> keyExtractor) {
        return thenComparing(comparingDouble(keyExtractor));
    }
    // 1.8新增靜態方法：用於得到一個相反的排序的比較器，這裡針對的是內置的排序方式（即繼承Comparable）
    public static <T extends Comparable<? super T>> Comparator<T> reverseOrder() {
        return Collections.reverseOrder();
    }
    // 1.8新增靜態方法：用於得到一個實現了Comparable介面的類的比較方式的比較器
    // 簡言之就是將Comparable定義的比較方式使用Comparator實現
    @SuppressWarnings("unchecked")
    public static <T extends Comparable<? super T>> Comparator<T> naturalOrder() {
        return (Comparator<T>) Comparators.NaturalOrderComparator.INSTANCE;
    }
    // 1.8新增靜態方法：得到一個null親和的比較器，null小於非null，兩個null相等，如果全不是null,
    // 則使用指定的比較器比較，若未指定比較器，則非null全部相等返回0
    public static <T> Comparator<T> nullsFirst(Comparator<? super T> comparator) {
        return new Comparators.NullComparator<>(true, comparator);
    }
    // 1.8新增靜態方法：得到一個null親和的比較器，null大於非null，兩個null相等，如果全不是null,
    // 則使用指定的比較器比較，若未指定比較器，則非null全部相等返回0
    public static <T> Comparator<T> nullsLast(Comparator<? super T> comparator) {
        return new Comparators.NullComparator<>(false, comparator);
    }
    // 1.8新增靜態方法：使用指定的鍵比較器用於執行鍵的比較
    public static <T, U> Comparator<T> comparing(
            Function<? super T, ? extends U> keyExtractor,
            Comparator<? super U> keyComparator)
    {
        Objects.requireNonNull(keyExtractor);
        Objects.requireNonNull(keyComparator);
        return (Comparator<T> & Serializable)
            (c1, c2) -> keyComparator.compare(keyExtractor.apply(c1),
                                              keyExtractor.apply(c2));
    }
    // 1.8新增靜態方法：執行鍵比較，採用內置比較方式，key的類必須實現Comparable
    public static <T, U extends Comparable<? super U>> Comparator<T> comparing(
            Function<? super T, ? extends U> keyExtractor)
    {
        Objects.requireNonNull(keyExtractor);
        return (Comparator<T> & Serializable)
            (c1, c2) -> keyExtractor.apply(c1).compareTo(keyExtractor.apply(c2));
    }
    // 1.8新增靜態方法：用於int類型鍵的比較
    public static <T> Comparator<T> comparingInt(ToIntFunction<? super T> keyExtractor) {
        Objects.requireNonNull(keyExtractor);
        return (Comparator<T> & Serializable)
            (c1, c2) -> Integer.compare(keyExtractor.applyAsInt(c1), keyExtractor.applyAsInt(c2));
    }
    // 1.8新增靜態方法：用於long類型鍵的比較
    public static <T> Comparator<T> comparingLong(ToLongFunction<? super T> keyExtractor) {
        Objects.requireNonNull(keyExtractor);
        return (Comparator<T> & Serializable)
            (c1, c2) -> Long.compare(keyExtractor.applyAsLong(c1), keyExtractor.applyAsLong(c2));
    }
    // 1.8新增靜態方法：用於double類型鍵的比較
    public static<T> Comparator<T> comparingDouble(ToDoubleFunction<? super T> keyExtractor) {
        Objects.requireNonNull(keyExtractor);
        return (Comparator<T> & Serializable)
            (c1, c2) -> Double.compare(keyExtractor.applyAsDouble(c1), keyExtractor.applyAsDouble(c2));
    }
}

        老版本的Comparator中只要兩個方法，就是前兩個方法，後面的所有預設方法均為1.8新增的方法，採用的是1.8新增的功能：介面可添加預設方法。即便擁有如此多方法，該介面還是函數式介面，compare用於定義比較方式。

四、二者比較

        Comparable可以看做是內部比較器，Comparator可以看做是外部比較器。

        一個類，可以通過實現Comparable介面來自帶有序性，也可以通過額外指定Comparator來附加有序性。

        二者的作用其實是一致的，所以不要混用。

        我們看個例子吧：

        首先定義個模型：User

public class User implements Serializable, Comparable<User> {
    private static final long serialVersionUID = 1L;
    private int age;
    private String name;
    public User (){}
    public User (int age, String name){
        this.age = age;
        this.name = name;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public int compareTo(User o) {
        return this.age - o.age;
    }
    @Override
    public String toString() {
        return "[user={age=" + age + ",name=" + name + "}]";
    }
}

        在定義一個Comparator實現類MyComparator

public class MyComparator implements Comparator<User> {
    @Override
    public int compare(User o1, User o2) {
        return o1.getName().charAt(0)-o2.getName().charAt(0);
    }
}

        最後是測試類：Main

public class Main {
    public static void main(String[] args) {
        User u1 = new User(12, "xiaohua");
        User u2 = new User(10, "abc");
        User u3 = new User(15,"ccc");
        User[] users = {u1,u2,u3};
        System.out.print("數組排序前：");
        printArray(users);
        System.out.println();
        Arrays.sort(users);
        System.out.print("數組排序1後：");
        printArray(users);
        System.out.println();
        Arrays.sort(users, new MyComparator());
        System.out.print("數組排序2後：");
        printArray(users);
        System.out.println();
        Arrays.sort(users, Comparator.reverseOrder());// 針對內置的排序進行倒置
        System.out.print("數組排序3後：");
        printArray(users);
    }
    public static void printArray (User[] users) {
        for (User user:users) {
            System.out.print(user.toString());
        }
    }
}

        運行結果為：

數組排序前：[user={age=12,name=xiaohua}][user={age=10,name=abc}][user={age=15,name=ccc}]
數組排序1後：[user={age=10,name=abc}][user={age=12,name=xiaohua}][user={age=15,name=ccc}]
數組排序2後：[user={age=10,name=abc}][user={age=15,name=ccc}][user={age=12,name=xiaohua}]
數組排序3後：[user={age=15,name=ccc}][user={age=12,name=xiaohua}][user={age=10,name=abc}]

        通過上面的例子我們有一個結論，那就是兩種方式定義排序的優先順序，明顯Comparator比較器要優先於內部排序Comparable。

五、總結

  • Comparable為可排序的，實現該介面的類的對象自動擁有可排序功能。
  • Comparator為比較器，實現該介面可以定義一個針對某個類的排序方式。
  • Comparator與Comparable同時存在的情況下，前者優先順序高。

參考：


您的分享是我們最大的動力!

-Advertisement-
Play Games
更多相關文章
  • 洛谷P2178 [NOI2015]品酒大會(尾碼自動機 線段樹)
    題意 "題目鏈接" Sol 說一個尾碼自動機+線段樹的無腦做法 首先建出SAM，然後對parent樹進行dp，維護最大次大值，最小次小值 顯然一個串能更新答案的區間是$[len_{fa_{x}} + 1, len_x]$，方案數就相當於是從$siz_x$裡面選兩個，也就是$\frac{siz_x ( ...
  • Springboot 系列（三）Spring Boot 自動配置原理
    註意：本 Spring Boot 系列文章基於 Spring Boot 版本 v2.1.1.RELEASE 進行學習分析，版本不同可能會有細微差別。 前言 關於配置文件可以配置的內容，在 "Spring Boot 官方網站" 已經提供了完整了配置示例和解釋。 可以這麼說，Spring Boot 的一 ...
  • 利用python暴力破解壓縮文件密碼
    import randomimport sysimport zipfileimport timefrom threading import Threadfrom multiprocessing import Processclass MyIterator: # letters = '01234567... ...
  • Go語言相對於C++的優點
    Go語言是Google公司在2009年開源的一門高級編程語言，它為解決大型系統開發過程中的實際問題而設計，支持併發、規範統一、簡單優雅，被很多Go語言傳道者譽為“互聯網時代的C語言”。而C++語言誕生於1979年，可以將C++語言視為一個語言聯邦，主要包含C語言（面向過程）、面向對象、STL容器和算 ...
  • 簡單介紹Java的靜態分派和動態分派
    最近複習JVM的知識，對於靜態分派和動態分派的理解有點混亂，於是自己嘗試寫寫代碼，在分析中鞏固知識。 有如下一段代碼，請問每一段分別輸出什麼？ 下麵我簡單地介紹一下從代碼編譯到方法調用的整個過程。 · 編譯 先看看第1段輸出，child.foo()是調用父類還是子類的靜態方法呢？ 在編譯階段，發生了 ...
  • Java中replace與replaceAll區別
    看門見山 1.java中replace API： replace(char oldChar, char newChar)：寓意為：返回一個新的字元串，它是通過用 newChar 替換此字元串中出現的所有 oldChar 得到的。 replace(CharSequence target, CharSe ...
  • Python3中列表字元串轉數字
    比如我們有個列表： 如果我們需要將列表裡的元素轉換為數字呢？最常用的大家可能會想到使用列表推導式： 輸出：[1, 2, 3, 4] 還有一種技巧，更方便： 輸出：[1, 2, 3, 4] ...
  • bzoj4514 數字配對
    思路 首先想到費用流。 對於每個點拆點。然後考慮我們怎樣才能保證每個點只被用一次。 如果$i$與$j$滿足條件。那麼就從$i$向$j$連一條邊並且從$j$向$i$連一條 ...
一周排行
    -Advertisement-
    Play Games
  • 移動開發（一）：使用.NET MAUI開發第一個安卓APP
    移動開發（一）：使用.NET MAUI開發第一個安卓APP 對於工作多年的C#程式員來說，近來想嘗試開發一款安卓APP，考慮了很久最終選擇使用.NET MAUI這個微軟官方的框架來嘗試體驗開發安卓APP，畢竟是使用Visual Studio開發工具，使用起來也比較的順手，結合微軟官方的教程進行了安卓 ...
  • wpf ToggleButton選中效果和一個登錄界面
    前言 QuestPDF 是一個開源 .NET 庫，用於生成 PDF 文檔。使用了C# Fluent API方式可簡化開發、減少錯誤並提高工作效率。利用它可以輕鬆生成 PDF 報告、發票、導出文件等。 項目介紹 QuestPDF 是一個革命性的開源 .NET 庫，它徹底改變了我們生成 PDF 文檔的方 ...
  • 彈幕樹洞項目功能新增篇
    項目地址 項目後端地址： https://github.com/ZyPLJ/ZYTteeHole 項目前端頁面地址： ZyPLJ/TreeHoleVue (github.com) https://github.com/ZyPLJ/TreeHoleVue 目前項目測試訪問地址： http://tree ...
  • 第27篇 sqlserver2022詳細安裝步驟
    話不多說，直接開乾 一.下載 1.官方鏈接下載： https://www.microsoft.com/zh-cn/sql-server/sql-server-downloads 2.在下載目錄中找到下麵這個小的安裝包 SQL2022-SSEI-Dev.exe，運行開始下載SQL server； 二. ...
  • .NET 開源高性能 MQTT 類庫
    前言 隨著物聯網（IoT）技術的迅猛發展，MQTT（消息隊列遙測傳輸）協議憑藉其輕量級和高效性，已成為眾多物聯網應用的首選通信標準。 MQTTnet 作為一個高性能的 .NET 開源庫，為 .NET 平臺上的 MQTT 客戶端與伺服器開發提供了強大的支持。 本文將全面介紹 MQTTnet 的核心功能 ...
  • Serilog文檔翻譯系列（六） - 可用的接收器、增強器、格式化輸出
    Serilog支持多種接收器用於日誌存儲，增強器用於添加屬性，LogContext管理動態屬性，支持多種輸出格式包括純文本、JSON及ExpressionTemplate。還提供了自定義格式化選項，適用於不同需求。 ...
  • 警惕 Visual Studio 屬性求值副作用導致邏輯不符合預期
    目錄簡介獲取 HTML 文檔解析 HTML 文檔測試參考文章 簡介 動態內容網站使用 JavaScript 腳本動態檢索和渲染數據，爬取信息時需要模擬瀏覽器行為，否則獲取到的源碼基本是空的。 本文使用的爬取步驟如下： 使用 Selenium 獲取渲染後的 HTML 文檔 使用 HtmlAgility ...
  • [使用目前最新版]HybridCLR6.9.0+YooAsset2.2.4實現純C# Unity熱更新方案 (一)
    1.前言 什麼是熱更新 游戲或者軟體更新時，無需重新下載客戶端進行安裝，而是在應用程式啟動的情況下，在內部進行資源或者代碼更新 Unity目前常用熱更新解決方案 HybridCLR，Xlua，ILRuntime等 Unity目前常用資源管理解決方案 AssetBundles，Addressable， ...
  • 在 ASP.NET Core Web API 中使用操作篩選器統一處理通用操作
    本文章主要是在C# ASP.NET Core Web API框架實現向手機發送驗證碼簡訊功能。這裡我選擇是一個互億無線簡訊驗證碼平臺，其實像阿裡雲，騰訊雲上面也可以。 首先我們先去 互億無線 https://www.ihuyi.com/api/sms.html 去註冊一個賬號 註冊完成賬號後，它會送 ...
  • 第28篇 如何.net中實現高效可靠數據同步api
    通過以下方式可以高效，並保證數據同步的可靠性 1.API設計 使用RESTful設計，確保API端點明確，並使用適當的HTTP方法（如POST用於創建，PUT用於更新）。 設計清晰的請求和響應模型，以確保客戶端能夠理解預期格式。 2.數據驗證 在伺服器端進行嚴格的數據驗證，確保接收到的數據符合預期格 ...
所有分類