2019-01-23 接口Comparable
我們在字符串中見到過CompareTo方法,知道這個方法是用於比較字符串順序的,根據字典順序進行排序。Java中很多類也都有CompareTo方法，甚至於排序算法的底層組成也是依賴於比較的，而這個比較就是依賴於各種數據類型的CompareTo或者Compare方法。Java中所有的compareTo方法都源於一個共同的接口，那就是Comparable。這個接口只有一個方法，那就是CompareTo。所有想要具有比較功能的類，都建議實現這個接口，而非是自己定義這個功能，這是面向對象的概念（將具有相同功能的事物抽象到一個共同的類或接口），並且為了多態也建議通過實現接口來進行向上轉型，通過接口來操作具體實現，這也是面向接口編程要求我們做的。下面我們來具體了解一下Comparable接口。
1. 接口概述
查看API我們發現對Comparable定義如下：
public interface Comparable<T>
此接口強行對實現它的每個類的對象進行整體排序。這種排序被稱為類的自然排序，類的 compareTo 方法被稱為它的自然比較方法。實現此接口的對象列表（和數組）可以通過 Collections.sort（和 Arrays.sort）進行自動排序。實現此接口的對象可以用作有序映射中的鍵或有序集合中的元素，無需指定比較器。
對於類 C(Collections) 的每一個 e1 (Element)和 e2 來說，當且僅當 e1.compareTo(e2) == 0 與 e1.equals(e2) 具有相同的 boolean 值時，類 C 的自然排序才叫做與 equals 一致。注意，null 不是任何類的實例，即使 e.equals(null) 返回 false，e.compareTo(null) 也將拋出 NullPointerException。【這里也給了我們一種比較兩個數據內容的方法compareTo,如果返回值為0說明比較的內容相同,在下一節詳細方法介紹中我們再探討!】。建議（雖然不是必需的）最好使自然排序與 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）視為相等。 從數學上講，定義給定類 C 上自然排序的關系式 如下：
{(x, y)|x.compareTo(y) <= 0}。
整體排序的商是：
{(x, y)|x.compareTo(y) == 0}。
它直接遵循 compareTo 的協定，商是 C 的等價關系，自然排序是 C 的整體排序。當說到類的自然排序與 equals 一致 時，是指自然排序的商是由類的 equals(Object) 方法定義的等價關系。
{(x, y)|x.equals(y)}。
此接口是 Java Collections Framework 的成員。
2. 接口方法詳讀
接口和類一樣都是對共有功能的抽象，不同的是類中的功能是具體的實現，而接口的則是對一個功能的抽象。下面我們了解一下Comparable接口的抽象方法，該接口只提供了一個方法，接口方法如下：
| int |
如上所訴，該方法用於比較此對象與指定對象的順序。如果該對象小於、等於或大於指定對象，則分別返回負整數、零或正整數。 根據不同類的實現返回不同，大部分返回1,0和-1三個數，如下測試：
| @Test public void test1(){ Integer i1 = 3; Integer i2 = 7; System.out.println(i2.compareTo(i1));//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 不一致的自然排序。”
在前面的描述中，符號 sgn(expression) 指定 signum 數學函數，該函數根據 expression 的值是負數、零還是正數，分別返回 -1、0 或 1 中的一個值。
注意會拋出的異常:ClassCastException - 如果指定對象的類型不允許它與此對象進行比較。
3. 接口方法的實踐操作
編程最好的學習莫過於大量的代碼,通過代碼發現問題,下面我們就自己來實踐一下Comparable的方法.
3.1 String和Integer對於compareTo()的實現
String和Integer這兩個類都實現了Comparable接口,都對compareTo方法進行了實現,下面我們通過源碼來看一下它們各自對於該方法的具體實現:
private final char value[];//String的底層是字符數組 a.compareTo(b) public int compareTo(String anotherString) { int len1 = value.length;//獲取調用該方法的字符串的長度a int len2 = anotherString.value.length;//獲取比較字符串的長度b int lim = Math.min(len1, len2);//(a <= b) ? a : b; min底層代碼 這句代碼是為了獲取較短的字符串的長度 char v1[] = value; //創建兩個字符數組,分別指向這兩個字符串的所在 char v2[] = anotherString.value; //循環比較,循環次數,是較短的字符串的長度,如果用較長的字符串的長度,那么會出現nullPointException int k = 0; while (k < lim) { char c1 = v1[k]; char c2 = v2[k]; //比較相對應索引的元素,如果元素不同則比較返回中間差距的順序,如果相等,那么就繼續循環比較 if (c1 != c2) { return c1 - c2;//字符對應的Unicode碼表中的數字,這也就是為什么說String是按照字典書序比較的,如a比b靠前,那么a對應的數字比b小,相減返回負數,差多少順序,就返回多少 } k++; } //如果兩個字符串的長度不同,其它都相同,那么返回的就是長度的差距了 return len1 - len2; }
我們可以看到String對於compareTo的實現就是依據Unicode碼表中字符對應的數字來判斷的,返回的是字符串長度差或者是字符間在碼表上的差距,依據具體情況,返回也不同.下面我們看看Integer的compareTo();
//Integer的compareTo方法,底層依據的是compare方法,這個方法是Comparator接口的一個方法 public int compareTo(Integer anotherInteger) { //實際上Integer的比較是通過Integer中包括的整數來比較的 return compare(this.value, anotherInteger.value); } public static int compare(int x, int y) {//a.compateTo(b) //如果a比b小,那么返回-1,相等就是0,否則就是1 return (x < y) ? -1 : ((x == y) ? 0 : 1); }
有了對String和Integer的compareTo的實現的了解,下面我們試着自己來實現一個類的compareTo方法;
package cn.comparable.introduce; public class ComparableLength implements Comparable<ComparableLength>{ @Override public int compareTo(ComparableLength o) { int len1 = Integer.toString(this.hashCode(), 16).length(); int len2 = Integer.toString(o.hashCode(), 16).length(); return (len1 - len2 > 0) ? 1 : -1 ; } public String sort(ComparableLength cl){ if(this.compareTo(cl) == 1){ return "該對象比后者hashcode長度長"; }else { return "該對象比后者hashcode長度短,也可能相等"; } } }
@Test public void test3(){ ComparableLength c1 = new ComparableLength(); ComparableLength c2 = new ComparableLength(); ComparableLength c3 = new ComparableLength(); ComparableLength c4 = c1; System.out.println(c1.sort(c2) + c1.hashCode()); System.out.println(c2.sort(c1)); System.out.println(c2.sort(c3) + c2.hashCode()); System.out.println(c1.sort(c3) + c3.hashCode()); System.out.println(c4.sort(c3) + c4.hashCode()); }
如上我們自己也能寫一個比較方法了,但是這個方法只簡單比較了一下對象的hashcode的長度，下面我們比較一下hashcode是否相等，和equals()返回同樣結果,這也是建議我們做的;
package cn.comparable.introduce; import org.junit.runner.manipulation.Sortable; public class ComparableLength implements Comparable<ComparableLength>{ public String sort(ComparableLength c2){ if(this.compareTo(c2) == 1) return "這兩個對象不是同一個對象"; else return "這兩個對象是同一個對象"; } @Override public int compareTo(ComparableLength o) { String str1 = Integer.toString(this.hashCode()); String str2 = Integer.toString(o.hashCode()); int len1 = str1.length(); int len2 = str2.length(); char[] ch1 = str1.toCharArray(); char[] ch2 = str2.toCharArray(); int lim = len1 - len2 ; if(lim == 0){ int k = 0; while (k < len1) { char char1 = ch1[k]; char char2 = ch2[k]; if(char1 != char2) return 1; k++; } }else if(lim != 0) return 1; return 0; } }
@Test public void test4(){ ComparableLength c1 = new ComparableLength(); ComparableLength c2 = new ComparableLength(); ComparableLength c3 = new ComparableLength(); ComparableLength c4 = c1; System.out.println(c1.sort(c2) + "--"+c1.equals(c2)+"--"+c1.hashCode()); System.out.println(c2.sort(c1) + "--"+c2.equals(c1)); System.out.println(c2.sort(c3) + "--"+c2.equals(c3)+"--"+c2.hashCode()); System.out.println(c1.sort(c3) + "--"+c1.equals(c3)+"--"+ c3.hashCode()); System.out.println(c4.sort(c1) + "--"+c4.equals(c1)+"--"+ c4.hashCode()); }
我們發現可以實現該功能;
Java中除了提供一個比較方法的接口外,還提供了一個比較器的接口Comparator,下節我們來讀一下Comparator。