集合 排序 Comparator 和 Comparator [MD]

博文地址

我的GitHub	我的博客	我的微信	我的郵箱
baiqiantao	baiqiantao	bqt20094	[e-mail]

---

測試案例

• Comparable 接口是讓類自身具有排序功能
• Comparator 接口是對 Collection 進行整體排序的功能

測試兩個接口方法的返回值

實體類

class MyBean implements Comparable<MyBean> {
    public Integer age;

    public MyBean(int age) {
        this.age = age;
    }

    @Override
    public int compareTo(MyBean o) {
        return -1; //下面案例中更改的都是這個值
    }

    @Override
    public String toString() {
        return age + "";
    }
}

測試 Comparable

List<MyBean> list = Arrays.asList(new MyBean(2), new MyBean(3), new MyBean(1), new MyBean(2));
Collections.sort(list);
System.out.println(list); 

原始排序為 [2, 3, 1, 2]
【-1】// [2, 1, 3, 2]，一定要注意，返回 -1 的意義不是 this.age - o.age 的值一直為 -1 ，這兩種情況的排序結果是完全不一樣的
【1】// [2, 3, 1, 2]
【0】// [2, 3, 1, 2]
【this.age.compareTo(o.age)】//[1, 2, 2, 3]
【this.age - o.age】// [1, 2, 2, 3]
【o.age.compareTo(this.age)】//[3, 2, 2, 1]

測試 Comparator

Integer[] array = { 2, 3, 1, 2 };
//MyBean[] array = { new MyBean(2), new MyBean(3), new MyBean(1), new MyBean(2) }; //這種方式和上面的結果也是完全一樣的
Arrays.sort(array, (o1, o2) -> -1); //下面案例中更改的都是這個值
System.out.println(Arrays.toString(array));

原始排序為 [2, 3, 1, 2]
【-1】// [2, 1, 3, 2]，一定要注意，返回 -1 的意義不是 o1 - o2 的值一直為 -1 ，這兩種情況的排序結果是完全不一樣的
【1】// [2, 3, 1, 2]
【0】// [2, 3, 1, 2]
【o1.compareTo(o2)】//[1, 2, 2, 3]
【o1 - o2】// [1, 2, 2, 3]
【o2.compareTo(o1)】//[3, 2, 2, 1]

總結

• 可以發現，(一般情況下) Comparator 比較的結果和 Comparable 是完全一致的。
• 以上兩種情況，經測試，使用集合與使用數組排序后的結果是完全一致的。
• 當指定比較器 Comparator 時，僅會通過指定比較器對元素排序，實現 Comparable 的元素的自然排序將不再有任何意義。

元素為空的情況

測試 Comparable

如果需要用到 compareTo 方法去比較元素，則不允許除了首個元素外其余任何元素為空。

class A implements Comparable<A> {
    @Override
    public int compareTo(A o) {
        return 1;
    }
}
class B implements Comparable<B> {
    @Override
    public int compareTo(B o) {
        return -1;
    }
}

// 首個元素為空的情況
A[] array1 = { null, new A() };
B[] array2 = { null, new B() };
Arrays.sort(array1); 
Arrays.sort(array2); 
System.out.println(Arrays.toString(array1)); //[null, A@15db9742]
System.out.println(Arrays.toString(array2)); //[B@7852e922, null]

//非首個元素為空的情況
A[] array1 = { new A(), null };
B[] array2 = { new B(), null };
Arrays.sort(array1); //NullPointerException
Arrays.sort(array2); //NullPointerException

測試 Comparator

完全由你控制是否可以有元素為空，所以這個功能更強大、兼容性更強。

class C { }
C[] array = { null, new C(), null, null };
Arrays.sort(array, (o1, o2) -> 1); //對象的比較完全由你在 compare 方法中控制

Comparator 的使用案例

實體類

class Person {
    public String name;
    public int age;
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    @Override
    public String toString() {
        return "{age=" + age + " ,name=" + name + "}";
    }
}

Comparator

class MyComparator implements Comparator<Person> {
    @Override
    public int compare(Person o1, Person o2) {
        if (o2 == null) { //如果后面的一個元素為空，則保持其位置
            return -1; //這一行代碼的意義並不是將 (后面的)空元素 放在最后一個位置，而僅僅是保持元素的位置，不進行任何換位操作
        } else if (o1 == null) { 
            return 1; //如果前面的一個元素為空，則和后一個元素更換其位置
        } else { //如果兩者都不為空，則先比較年齡，再比較姓名
            if (o1.age != o2.age) { //如果年齡不相等，則先按年齡由小到大排序
                return o1.age - o2.age; //其實這種表達式就是最標准的自然排序方式
            } else {
                if (o2.name == null) { //判斷姓名時也同樣先判斷姓名是否為空
                    return -1; //如果后面的一個元素的姓名為空，則保持其位置
                } else if (o1.name == null) {
                    return 1; //如果前面的一個元素的姓名為空，則和后一個元素更換其位置
                } else {
                    return o1.name.compareTo(o2.name); //如果都不為空，則直接用String的自然排序方式排序
                }
            }
        }
    }
}

測試代碼

Person[] array = { null, new Person(null, 1), new Person(null, 2), new Person("ab", 1), new Person("ab", 2), null, new Person("ac", 2), new Person("a", 2) };
Arrays.sort(array, new MyComparator());
System.out.println(Arrays.toString(array));
//[{age=1 ,name=ab}, {age=1 ,name=null}, 
//{age=2 ,name=a}, {age=2 ,name=ab}, {age=2 ,name=ac}, 
//{age=2 ,name=null}, null, null]

官方 API

接口 Comparable：類的自然排序

官方文檔

public interface java.lang.Comparable<T>

類型參數：T - 可以與此對象進行比較的那些對象的類型

此接口強行對實現它的每個類的對象進行整體排序。這種排序被稱為類的自然排序，類的 compareTo 方法被稱為它的自然比較方法。

實現此接口的對象列表和數組可以通過 Collections.sort 和 Arrays.sort 進行自動排序。實現此接口的對象可以用作有序映射 SortedMap<K,V> 中的鍵或有序集合 SortedSet<E> 中的元素，無需指定比較器。

划重點，Comparable 的最重要的適用場景為：

Collections.sort
Arrays.sort
SortedMap<K,V>
SortedSet<E>

對於類 C 的每一個 e1 和 e2 來說，當且僅當 e1.compareTo(e2) == 0 與 e1.equals(e2) 具有相同的 boolean 值時，類 C 的自然排序才叫做與 equals 一致。

注意，null 不是任何類的實例，即使 e.equals(null) 返回 false，e.compareTo(null) 也將拋出 NullPointerException。

建議最好使自然排序與 equals 一致。這是因為在使用自然排序與 equals 不一致的元素(或鍵)時，沒有顯式比較器的有序集合(和有序映射表)行為表現“怪異”。尤其是，這樣的有序集合(或有序映射表)違背了根據 equals 方法定義的集合(或映射表)的常規協定。

例如，如果將兩個鍵 a 和 b 添加到沒有使用顯式比較器的有序集合中，使 (!a.equals(b) && a.compareTo(b) == 0)，那么第二個 add 操作將返回 false(有序集合的大小沒有增加)，因為從有序集合的角度來看，a 和 b 是相等的。

實際上，所有實現 Comparable 的 Java 核心類都具有與 equals 一致的自然排序。java.math.BigDecimal 是個例外，它的自然排序將值相等但精確度不同的 BigDecimal 對象(比如 4.0 和 4.00)視為相等。

compareTo 方法

int compareTo(T o) //比較此對象與指定對象的順序

為防止記亂，可以這么記： a.compareTo(b) 代表的是 a-b 的值，正值代表 a>b ，所以被比較的是小對象，那么被比較的對象應該放前面，這時就需要做一次調換位置的操作了。

• 參數：o - 要比較的對象。
• 返回：如果該對象小於、等於或大於指定對象，則分別返回負整數、零或正整數。
• 拋出：ClassCastException - 如果指定對象的類型不允許它與此對象進行比較。

使用須知

sgn(expression)

表示 signum 數學函數，該函數根據 expression 的值是負數、零還是正數，分別返回 -1、0 或 1 中的一個值

• 實現類必須確保對於所有的 x 和 y 都存在 sgn(x.compareTo(y)) == -sgn(y.compareTo(x)) 的關系。這意味着如果 y.compareTo(x) 拋出一個異常，則 x.compareTo(y) 也要拋出一個異常。
• 實現類還必須確保關系是可傳遞的：(x.compareTo(y)>0 && y.compareTo(z)>0) 意味着 x.compareTo(z)>0 。
• 實現者必須確保 x.compareTo(y)==0 意味着對於所有的 z，都存在 sgn(x.compareTo(z)) == sgn(y.compareTo(z))。
• 強烈推薦 (x.compareTo(y)==0) == (x.equals(y)) 這種做法，但並不是 嚴格要求這樣做。一般來說，任何實現 Comparable 接口和違背此條件的類都應該清楚地指出這一事實。推薦如此闡述：“注意：此類具有與 equals 不一致的自然排序。”

接口 Comparator：集合的比較器

官方文檔

public interface java.util.Comparator<T>

類型參數：T - 此 Comparator 可以比較的對象類型

強行對某個對象 Collection 進行整體排序的比較函數。可以將 Comparator 傳遞給 sort 方法(如 Collections.sort 或 Arrays.sort)，從而允許在排序順序上實現精確控制。還可以使用 Comparator 來控制某些數據結構(如有序集合 SortedSet<E> 或有序映射 SortedMap<K,V> )的順序，或者為那些沒有自然順序的對象 Collection 提供排序。

當且僅當對於一組元素 S 中的每個 e1 和 e2 而言，c.compare(e1, e2)==0 與 e1.equals(e2) 具有相等的布爾值時，Comparator c 強行對 S 進行的排序才叫做與 equals 一致的排序。

當使用具有與 equals 不一致的強行排序能力的 Comparator 對有序 set(或有序映射)進行排序時，應該小心謹慎。假定一個帶顯式 Comparator c 的有序 set(或有序映射)與從 set S 中抽取出來的元素(或鍵)一起使用。如果 c 強行對 S 進行的排序是與 equals 不一致的，那么有序 set(或有序映射)將是行為“怪異的”。尤其是有序 set(或有序映射)將違背根據 equals 所定義的 set(或映射)的常規協定。

例如，假定使用 Comparator c 將滿足 (a.equals(b) && c.compare(a, b) != 0) 的兩個元素 a 和 b 添加到一個空 TreeSet 中，則第二個 add 操作將返回 true(樹 set 的大小將會增加)，因為從樹 set 的角度來看，a 和 b 是不相等的，即使這與 Set.add 方法的規范相反。

注：通常來說，讓 Comparator 也實現 java.io.Serializable 是一個好主意，因為它們在可序列化的數據結構(像 TreeSet、TreeMap)中可用作排序方法。為了成功地序列化數據結構，Comparator(如果已提供)必須實現 Serializable。

compare 方法

int compare(T o1, T o2) //比較用來排序的兩個參數。

為防止記亂，可以這么記： compare(b, a) 代表的是 a-b 的值，正值代表 a>b ，所以 b 是小對象，那么 b 應該放前面，這時就需要做一次調換位置的操作了。

• 參數：o1 - 要比較的第一個對象。o2 - 要比較的第二個對象。
• 返回：根據第一個參數小於、等於或大於第二個參數分別返回負整數、零或正整數。
• 拋出：ClassCastException - 如果參數的類型不允許此 Comparator 對它們進行比較。

equals 方法

boolean equals(Object obj)` // 指示某個其他對象是否“等於”此 Comparator

注意，這里的 equals 指的是比較器 Comparator 的 equals，也即比較器之間是否 equals，而不是比較器要比較的對象之間是否 equals。

• 覆蓋：類 Object 中的 equals
• 參數：obj - 要進行比較的引用對象。
• 返回：僅當指定的對象也是一個 Comparator，並且強行實施與此 Comparator 相同的排序時才返回 true。
• 另請參見：Object.equals(Object), Object.hashCode()

此方法必須遵守 Object.equals(Object) 的常規協定。此外， 僅當 指定的對象也是一個 Comparator，並且強行實施與此 Comparator 相同的排序時，此方法才返回 true。因此，comp1.equals(comp2) 意味着對於每個對象引用 o1 和 o2 而言，都存在 sgn(comp1.compare(o1, o2)) ==sgn (comp2.compare(o1, o2))。

注意，不 重寫 Object.equals(Object) 方法總是 安全的。然而，在某些情況下，重寫此方法可以允許程序確定兩個不同的 Comparator 是否強行實施了相同的排序，從而提高性能。

使用須知

sgn(expression)

表示 signum 數學函數，該函數根據 expression 的值是負數、零還是正數，分別返回 -1、0 或 1 中的一個值

• 實現程序必須確保對於所有的 x 和 y 而言，都存在 sgn(compare(x, y)) == -sgn(compare(y, x))。這意味着如果 compare(y, x) 拋出一個異常，則 compare(x, y) 也要拋出一個異常。
• 實現程序還必須確保關系是可傳遞的：((compare(x, y)>0) && (compare(y, z)>0)) 意味着 compare(x, z)>0。
• 實現程序必須確保 compare(x, y)==0 意味着對於所有的 z 而言，都存在 sgn(compare(x, z)) == sgn(compare(y, z))。
• 強烈推薦 (compare(x, y)==0) == (x.equals(y)) 這種做法，但並不是 嚴格要求這樣做。一般說來，任何違背這個條件的 Comparator 都應該清楚地指出這一事實。推薦的語言是“注意：此 Comparator 強行進行與 equals 不一致的排序。”

2016-04-10