...
This noncompliant code example violates the third condition (transitivity) in the contract. This requirement states that the objects that compareTo() considers equal (returns 0) must be ordered the same with respect to other objects. Consider a Card that considers itself equal to any card of the same suit or same rank; otherwise it orders based on rank. This might arise in a game like Uno or Crazy Eights, where you can only place a card on the pile that shares a suit or rank with the top card on the pile.
| Code Block | ||
|---|---|---|
| ||
public final class Card implements Comparable {
private String suit;
private int rank;
public Card(String s, int r) {
if (s == null)
throw new NullPointerException();
suit = s;
rank = r;
}
public boolean equals(Object o) {
if (o instanceof Card){
Card c = (Card)o;
return suit.equals(c.suit) || (rank == c.rank); // bad
}
return false;
}
//This method violates its contract
public int compareTo(Object o){
if (o instanceof Card){
Card c = (Card)o;
if(suit.equals(c.suit))
return 0;
return c.rank - rank;
}
throw new ClassCastException();
}
public static void main(String[] args) {
Card a = new Card("Clubs", 2);
Card b = new Card("Clubs", 10);
Card c = new Card("Hearts", 7);
System.out.println(a.compareTo(b)); //returns 0
System.out.println(a.compareTo(c)); //returns a negative number
System.out.println(b.compareTo(c)); //returns a positive number
}
}
|
Here, the comparison between (a,c) yields that c is larger. But, (b,c) yields b as larger. This means b must be larger than a. However, (a,b) results in the value 0 (same).
Compliant Solution
Make sure you fulfill the compareTo() contract, and don't forget to make sure your corresponding equals() method matches with compareTo().
| Code Block | ||
|---|---|---|
| ||
public final class Card implements Comparable{
private String suit;
private int rank;
public Card(String s, int r) {
if (s == null)
throw new NullPointerException();
suit = s;
rank = r;
}
public boolean equals(Object o) {
if (o instanceof Card){
Card c=(Card)o;
return suit.equals(c.suit) && (rank == c.rank); // good
}
return false;
}
//this method fulfills its contract
public int compareTo(Object o){
if (o instanceof Card){
Card c=(Card)o;
if(suit.equals(c.suit))
return c.rank - rank;
return suit.compareTo(c.suit);
}
throw new ClassCastException();
}
public static void main(String[] args) {
Card a = new Card("Clubs", 2);
Card b = new Card("Clubs", 210);
Card c = new Card("Hearts", 7);
System.out.println(a.compareTo(b)); //returns 0
System.out.println(a.compareTo(c)); //returns a negative number
System.out.println(b.compareTo(c)); //returns a negative number
}
}
|
As per the ordering, c is larger than both a and b and the comparison (a,b) produces an "equal" result. This maintains the compareTo contract.
Exceptions
MET34-EX1: In some situations it may be necessary to violate the condition that (x.compareTo(y) == 0) == (x.equals(y) ). However, as this will make an object Comparable that , it should not be used in most data structures (like TreeSet and TreeMap) that deal with Comparable objects like TreeSet and TreeMap, it . It would be better to use a separate method entirely. If compatibility issues demand the use of this non-standard compareTo() method, care should be taken through comments or other means that the object is not used in data structures that expect a standard Comparable. If compatibility issues demand the use of this non-standard compareTo() method, care should be taken through comments or other means that the object is not used in data structures that expect a standard Comparable.
Risk Assessment
Violating the general contract when implementing the compareTo() method can lead to unexpected results, possibly leading to invalid comparisons and information disclosure.
...