Effective Java - 謹慎實現Comparable接口

類實現了Comparable接口就表明類的實例本身具有內在的排序關系(natural ordering)。
因此，該類可以與很多泛型算法和集合實現進行協作。
而我們之需要實現Comparable接口唯一的方法——compareTo。

以下是相關規則：

• sgn(x.compareTo(y)) = -sgn(y.compareTo(x))
• (x.compareTo(y)>0 && y.compareTo(z)>0) 則 x.compareTo(z)>0
• x.compareTo(y) == 0 則 sgn(x.compareTo(z)) == sgn(y.compareTo(z))
• 建議x.compareTo(y) == 0 時 x.equals(y)

第四條並不是必須的，但值得了解一下。
一些有序結構中的等同性比較可能會使用compareTo而非equals。
鑒於這種情況，我們需要把compareTo和equals兼容起來。
但特殊情況不必這樣，比如BigDecimal類中new BigDecimal("1.00")和new BigDecimal("1.0")，兩者equals結果為false，compareTo結果為0。

對於類中不同類型的field進行不同的比較方法：

• 非浮點基本類型直接使用關系操作符
• 浮點類型使用封裝類的compare方法
• 引用類型可以遞歸調用compareTo，如果發現某個field沒有實現Comparable，則提供顯示的Comparator。
• 數組類型則把上述規則應用到每一個元素。

通常情況下，對於一個類的關鍵field，我們可以根據它們的關鍵程度做一個優先級。
從最關鍵的開始逐個比較，得出非零結果時立即返回。

下面是例子：

// Making PhoneNumber comparable - Pages 65-66
package org.effectivejava.examples.chapter03.item12;

import java.util.NavigableSet;
import java.util.Random;
import java.util.TreeSet;

public final class PhoneNumber implements Cloneable, Comparable<PhoneNumber> {
    private final short areaCode;
    private final short prefix;
    private final short lineNumber;

    public PhoneNumber(int areaCode, int prefix, int lineNumber) {
        rangeCheck(areaCode, 999, "area code");
        rangeCheck(prefix, 999, "prefix");
        rangeCheck(lineNumber, 9999, "line number");
        this.areaCode = (short) areaCode;
        this.prefix = (short) prefix;
        this.lineNumber = (short) lineNumber;
    }

    private static void rangeCheck(int arg, int max, String name) {
        if (arg < 0 || arg > max)
            throw new IllegalArgumentException(name + ": " + arg);
    }

    @Override
    public boolean equals(Object o) {
        if (o == this)
            return true;
        if (!(o instanceof PhoneNumber))
            return false;
        PhoneNumber pn = (PhoneNumber) o;
        return pn.lineNumber == lineNumber && pn.prefix == prefix
                && pn.areaCode == areaCode;
    }

    @Override
    public int hashCode() {
        int result = 17;
        result = 31 * result + areaCode;
        result = 31 * result + prefix;
        result = 31 * result + lineNumber;
        return result;
    }



    @Override
    public PhoneNumber clone() {
        try {
            return (PhoneNumber) super.clone();
        } catch (CloneNotSupportedException e) {
            throw new AssertionError(); // Can't happen
        }
    }

    // Works fine, but can be made faster
    // public int compareTo(PhoneNumber pn) {
    // // Compare area codes
    // if (areaCode < pn.areaCode)
    // return -1;
    // if (areaCode > pn.areaCode)
    // return 1;
    //
    // // Area codes are equal, compare prefixes
    // if (prefix < pn.prefix)
    // return -1;
    // if (prefix > pn.prefix)
    // return 1;
    //
    // // Area codes and prefixes are equal, compare line numbers
    // if (lineNumber < pn.lineNumber)
    // return -1;
    // if (lineNumber > pn.lineNumber)
    // return 1;
    //
    // return 0; // All fields are equal
    // }

    public int compareTo(PhoneNumber pn) {
        // Compare area codes
        int areaCodeDiff = areaCode - pn.areaCode;
        if (areaCodeDiff != 0)
            return areaCodeDiff;

        // Area codes are equal, compare prefixes
        int prefixDiff = prefix - pn.prefix;
        if (prefixDiff != 0)
            return prefixDiff;

        // Area codes and prefixes are equal, compare line numbers
        return lineNumber - pn.lineNumber;
    }

    public static void main(String[] args) {
        NavigableSet<PhoneNumber> s = new TreeSet<PhoneNumber>();
        for (int i = 0; i < 10; i++)
            s.add(randomPhoneNumber());
        System.out.println(s);
    }

    private static final Random rnd = new Random();

    private static PhoneNumber randomPhoneNumber() {
        return new PhoneNumber((short) rnd.nextInt(1000),
                (short) rnd.nextInt(1000), (short) rnd.nextInt(10000));
    }
}

上面的例子中的field都是非浮點基本類型，於是作者對其進行優化。
鑒於compareTo只需要返回值的符號而非大小，因此用差值代替邏輯比較符。

但是這種用法需要注意，該field的類型可能無法容納兩個數值的差值。
比如Integer.MAX_VALUE-(-1)或者Integer.MIN_VALUE-1之類的。
如果可以保證field值不會是負值，則不會出現這種情況。