【Effective Java】Ch3_Methods：Item12_考虑实现Comparable接口

    与本章讨论的其他方法不同，compareTo方法并不是在Object类中声明的。相反，它是Comparable接口中的唯一方法。它与Object的equals方法有点类似，但它不仅仅是简单地进行相等性比较，还能执行顺序比较，同时它还是个泛型。类实现Comparable接口后，就表明其实例拥有自然顺序。若要对实现了Comparable接口的对象数组进行排序，只需要执行：

Arrays.sort(a);

    同样，对已排序的Comparable对象集合进行搜索、计算极值、自动维护也很简单。【例】例如String实现了Comparable接口，所以下面的程序能对命令行参数按字母顺序打印出来。

public class WordList {
  public static void main(String[] args) {
    Set<String> s = new TreeSet<String>();
    Collections.addAll(s, args);
    System.out.println(s);
  } 
}

    通过实现Comparable，可以让你的类与许多泛型算法，以及依赖于该接口的集合实现进行协作，通过很小的努力就能获得强大的功能。【例】实际上，JDK中的所有值类都实现了Comparable。

public final class String
    implements java.io.Serializable, Comparable<String>, CharSequence
{
  //Comparable接口
   public int compareTo(String anotherString) {
     ...
   }

  //自定义Comparator
    public static final Comparator<String> CASE_INSENSITIVE_ORDER
                                         = new CaseInsensitiveComparator();
    private static class CaseInsensitiveComparator
                         implements Comparator<String>, java.io.Serializable {
        public int compare(String s1, String s2) {
            int n1=s1.length(), n2=s2.length();
            for (int i1=0, i2=0; i1<n1 && i2<n2; i1++, i2++) {
                char c1 = s1.charAt(i1);
                char c2 = s2.charAt(i2);
                if (c1 != c2) {
                    c1 = Character.toUpperCase(c1);
                    c2 = Character.toUpperCase(c2);
                    if (c1 != c2) {
                        c1 = Character.toLowerCase(c1);
                        c2 = Character.toLowerCase(c2);
                        if (c1 != c2) {
                            return c1 - c2;
                        }
                    }
                }
            }
            return n1 - n2;
        }
    }

    //另一个自定义的compareTo
    public int compareToIgnoreCase(String str) {
        return CASE_INSENSITIVE_ORDER.compare(this, str);
    }    

}

    如果你编写的值类具有明显的自然顺序，例如字母顺序、数字顺序、年代顺序，那就应该强烈考虑实现Comparable接口：

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

    compareTo方法的通用约定与equals类似：

    将本对象与指定的对象进行比较，如果本对象小于、等于、或大于指定对象，则分别返回负数、零、或正数。如果指定的对象类型无法与本对象进行比较，则跑出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都有(x.compareTo(z)) == (y.compareTo(z))。
• 随不强制要求，但强烈建议(x.compareTo(y) == 0) == (x.equals(y))。一般来说，任何实现了Comparable的类如果违反了这个约定，都应该明确说明。推荐这么说：“注意：本类拥有自然顺序，但与equals不一致”。

    第一条指出，如果颠倒两个比较对象的比较顺序，就会发生以下情况：

• 如果第一个对象小于第二个对象，则第二个对象必须大于第一个对象；
• 如果第一个对象等于第二个对象，则第二个对象也必须等于第一个对象；
• 如果第一个对象大于第二个对象，则第二个对象小于第一个对象。
  

    第二条指出，如果第一个对象大于第二个对象，第二个对象大于第三个对象，则第一个大于第三个。

    第三条指出，对于两个相等的对象，他们与其他任何对象比较结果应该相同。

    这三条约定的一个结果是，compareTo方法的等同性测试必须与equals方法满足相同的约束条件：自反性、对称性、传递性。所以也存在相同的警告：不能在扩展一个可实例化的类并添加新的值组件时，同时保证compareTo的约定，除非你愿意放弃面向对象抽象的优势（Item8）。可以用与equals相同的规避措施：如果想在实现Comparable接口的类中增加一个值组件，就不要扩展它；应该写一个不相关的类，其中包含第一个类的实例。然后提供一个view方法返回该实例。这样你就可以再第二个类上实现任何compareTo方法，同时允许客户在必要的时候将第二个类看成是第一个类的一个实例。

    compareTo约定的最后一段是一个强烈的建议而非真正的约定，即compareTo方法的等同性测试必须与equals方法的结果相同。如果遵守了这一条，则称compareTo方法所施加的顺序与equals一致；反之则称为与equals不一致。当然与equals不一致的compareTo方法仍然是可以工作的，但是，如果一个有序集合包含了该类的元素，则这个集合可能就不能遵守相应集合接口（Collection、Set、Map）的通用约定。这是因为这些接口的通用约定是基于equals方法的，但是有序集合却使用了compareTo而非equals来执行等同性测试。尽管出现这种情况并不会造成灾难性后果，但是应该注意这种情况。

    【例】例如BigDecimal类的compareTo方法与equals不一致。如果创建一个HashSet实例，并添加两个元素new BigDecimal("1.0")和new BigDecimal("1.00")，则集合会包含两个元素，因为这两个实例通过equals检测并不相等；然而，如果使用TreeSet而非HashSet，则集合中会只包含一个元素，因为这两个实例通过compareTo检测是相等的。

    编写compareTo方法和编写equals方法是类似的，但也存在一些重大的差别。因为Comparable接口是参数化的，所以compareTo方法是静态的类型，无需进行类型检查或强制转换其参数。如果参数的类型是错的，这个调用甚至会无法编译。如果参数是null，则调用会抛出NullPointException，并在在该方法试图访问其成员时就会抛出。

    compareTo方法中的域比较是顺序比较而非等同性比较。比较对象引用时应该递归调用其compareTo方法。如果域未实现Comparable接口，或者你想使用非标准的顺序，则可以用一个显式的Comparator来比较。可以自己编写Comparator，或者使用之前定义过得Comparator，【例】例如String.compareToIgnoreCase

public final class String {
    //另一个自定义的compareTo
    public int compareToIgnoreCase(String str) {
        return CASE_INSENSITIVE_ORDER.compare(this, str);
    }    

}

    比较整数基本类型时，应该使用关系操作符 < 和 > 。对于浮点类型域，使用Double.compareTo或Float.compareTo，因为关系操作符对浮点类型的值不能遵守compareTo的通用约定。对于数组域，对每个元素进行比较。

    如果类中有多个关键域，则比较的顺序是很重要的。应该从最重要的域开始比较，如果比较结果是非0值，则比较结束；如果最重要的域是相等的，则继续比较次重要的域，以此类推；如果所有域都相等，则返回0。例如Item9中的compareTo方法：

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

    这个方法可以正常工作，但是还可以优化。 compareTo的通用约定并没有指定返回值的大小，而只是指定了符号。可以利用这一点来简化代码，或许还能提高运行速度：

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;
}

    这个技巧在这里工作的很好，但用起来要特别小心。除非你确信相关的域未非负数，或者更一般的情况： 域的最小可能值和最大可能值之差小于或等于Integer.MAX_VALUE。 这项技巧有时候并不能正常工作的原因是，有符号的32位整数并不足以存储两个有符号32位整数之差。如果i是一个大正数，j是一个大附属，则(i-j)会溢出并返回一个负数，会导致compareTo方法对某些参数返回错误的结果，并违反compareTo的第一条和第二条约定。这不仅仅是一个纯理论问题：他已经在实际系统中导致了失败，这些失败很难调试，因为这样的compareTo方法对大多数输入值均能正常工作。