Java中Comparable和Comparator的比較介紹（程式碼範例）

這篇文章帶給大家的內容是關於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

三、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同時存在的情況下，前者優先順序高。

以上是Java中Comparable和Comparator的比較介紹（程式碼範例）的詳細內容。更多資訊請關注PHP中文網其他相關文章！