Java Comparable 和 Comparator 的詳解及區別_java

Java Comparable 和 Comparator 的詳解及區別

Java 中為我們提供了兩種比較機制：Comparable 和 Comparator，他們之間有什麼區別呢？今天來瞭解一下。

Comparable 自然排序

Comparable 在 java.lang 包下，是一個介面，內部只有一個方法 compareTo()：

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

Comparable 可以讓實現它的類的對象進行比較，具體的比較規則是按照 compareTo 方法中的規則進行。這種順序稱為 自然順序。

compareTo 方法的傳回值有三種情況：

1. e1.compareTo(e2) > 0 即 e1 > e2
2. e1.compareTo(e2) = 0 即 e1 = e2
3. e1.compareTo(e2) < 0 即 e1 < e2

注意：

1.由於 null 不是一個類，也不是一個對象，因此在重寫 compareTo 方法時應該注意 e.compareTo(null) 的情況，即使 e.equals(null) 返回 false，compareTo 方法也應該主動拋出一個null 指標異常 NullPointerException。

2.Comparable 實作類別重寫 compareTo 方法時一般要求 e1.compareTo(e2) == 0 的結果要和 e1.equals(e2) 一致。這樣將來使用 SortedSet 等根據類的自然排序進行排序的集合容器時可以保證儲存的資料的順序和想象中一致。
有人可能好奇上面的第二點如果違反了會怎樣呢？

舉個例子，如果你往一個 SortedSet 中先後添加兩個對象 a 和 b，a b 滿足 (!a.equals(b) && a.compareTo(b) == 0)，同時也沒有另外指定個 Comparator，那當你添加完 a 再添加 b 時會添加失敗返回 false, SortedSet 的 size 也不會增加，因為在 SortedSet 看來它們是相同的，而 SortedSet 中是不允許重複的。

實際上所有實現了 Comparable 介面的 Java 核心類的結果都和 equlas 方法保持一致。
實現了 Comparable 介面的 List 或則數組可以使用 Collections.sort() 或者 Arrays.sort() 方法進行排序。

實現了 Comparable 介面的對象才能夠直接被用作 SortedMap (SortedSet) 的 key，要不然得在外邊指定 Comparator 定序。

因此自己定義的類如果想要使用有序的集合類，需要實現 Comparable 介面，比如：

** * description: 測試用的實體類 書, 實現了 Comparable 介面，自然排序 * <br/> * author: shixinzhang * <br/> * data: 10/5/2016 */public class BookBean implements Serializable, Comparable {  private String name;  private int count;  public BookBean(String name, int count) {    this.name = name;    this.count = count;  }  public String getName() {    return name;  }  public void setName(String name) {    this.name = name;  }  public int getCount() {    return count;  }  public void setCount(int count) {    this.count = count;  }  /**   * 重寫 equals   * @param o   * @return   */  @Override  public boolean equals(Object o) {    if (this == o) return true;    if (!(o instanceof BookBean)) return false;    BookBean bean = (BookBean) o;    if (getCount() != bean.getCount()) return false;    return getName().equals(bean.getName());  }  /**   * 重寫 hashCode 的計算方法   * 根據所有屬性進行 迭代計算，避免重複   * 計算 hashCode 時 計算因子 31 見得很多，是一個質數，不能再被除   * @return   */  @Override  public int hashCode() {    //調用 String 的 hashCode(), 唯一表示一個字串內容    int result = getName().hashCode();    //乘以 31, 再加上 count    result = 31 * result + getCount();    return result;  }  @Override  public String toString() {    return "BookBean{" +        "name='" + name + '\'' +        ", count=" + count +        '}';  }  /**   * 當向 TreeSet 中添加 BookBean 時，會調用這個方法進行排序   * @param another   * @return   */  @Override  public int compareTo(Object another) {    if (another instanceof BookBean){      BookBean anotherBook = (BookBean) another;      int result;      //比如這裡按照書價排序      result = getCount() - anotherBook.getCount();        //或者按照 String 的比較順序     //result = getName().compareTo(anotherBook.getName());      if (result == 0){  //當書價一致時，再對比書名。 保證所有屬性比較一遍        result = getName().compareTo(anotherBook.getName());      }      return result;    }    // 一樣就返回 0    return 0;  }

上述代碼還重寫了 equlas(), hashCode() 方法，自訂的類想要進行比較時都要重寫這些方法。

後面重寫 compareTo 時，要判斷某個相同時對比下一個屬性，把所有屬性都比較一次。

Comparable 介面屬於 Java 集合架構的一部分。

Comparator 定製排序

Comparator 在 java.util 包下，也是一個介面，JDK 1.8 以前只有兩個方法：

public interface Comparator<T> {  public int compare(T lhs, T rhs);  public boolean equals(Object object);}

JDK 1.8 以後又新增了很多方法：

基本上都是跟 Function 相關的，這裡暫不介紹 1.8 新增的。

從上面內容可知使用自然排序需要類實現 Comparable，並且在內部重寫 comparaTo 方法。

而 Comparator 則是在外部制定定序，然後作為排序策略參數傳遞給某些類，比如 Collections.sort(), Arrays.sort(), 或者一些內部有序的集合（比如 SortedSet，SortedMap 等）。

使用方式主要分三步：

1.建立一個 Comparator 介面的實作類別，並賦值給一個對象

在 compare 方法中針對自訂類寫定序

2.將 Comparator 對象作為參數傳遞給 排序類的某個方法

3.向排序類中添加 compare 方法中使用的自訂類

舉個例子：

 // 1.建立一個實現 Comparator 介面的對象    Comparator comparator = new Comparator() {      @Override      public int compare(Object object1, Object object2) {        if (object1 instanceof NewBookBean && object2 instanceof NewBookBean){          NewBookBean newBookBean = (NewBookBean) object1;          NewBookBean newBookBean1 = (NewBookBean) object2;          //具體比較方法參照 自然排序的 compareTo 方法，這裡只舉個栗子          return newBookBean.getCount() - newBookBean1.getCount();        }        return 0;      }    };    //2.將此對象作為形參傳遞給 TreeSet 的構造器中    TreeSet treeSet = new TreeSet(comparator);    //3.向 TreeSet 中添加 步驟 1 中 compare 方法中設計的類的對象    treeSet.add(new NewBookBean("A",34));    treeSet.add(new NewBookBean("S",1));    treeSet.add( new NewBookBean("V",46));    treeSet.add( new NewBookBean("Q",26));

其實可以看到，Comparator 的使用是一種策略模式，不熟悉策略模式的同學可以點這裡查看： 策略模式：網路小說的固定套路 瞭解。

排序類中持有一個 Comparator 介面的引用：

Comparator<? super K> comparator;
而我們可以傳入各種自訂定序的 Comparator 實作類別，對同樣的類制定不同的排序策略。

總結

Java 中的兩種排序方式：

Comparable 自然排序。（實體類實現）
Comparator 是定製排序。（無法修改實體類時，直接在調用方建立）

同時存在時採用 Comparator（定製排序）的規則進行比較。

對於一些普通的資料類型（比如 String, Integer, Double…），它們預設實現了Comparable 介面，實現了 compareTo 方法，我們可以直接使用。

而對於一些自訂類，它們可能在不同情況下需要實現不同的比較策略，我們可以新建立 Comparator 介面，然後使用特定的 Comparator 實現進行比較。

這就是 Comparable 和 Comparator 的區別。

感謝閱讀，希望能協助到大家，謝謝大家對本站的支援！