与本章讨论的其他方法不同,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方法对大多数输入值均能正常工作。