Question

I get the following error:

Comparison method violates its general contract!

This is my compareTo method

public int compareTo(ComparableItem another) {
     if (this.score == another.score)
        return this.getItemName().compareTo(another.getItemName());
     else if ((this.score) > another.score)
        return 1;
     else
        return -1;
}

I want to compare the scores of the items. But when the scores are the same I want to sort them by name.

What do I need to change and why do I get this error?

EDIT:

score is an int, itemname a String.

This is the ComparableItem class:

public abstract class ComparableItem extends MenuListItem implements Comparable<ComparableItem> {

protected int score;

public ComparableItem(String itemID, String itemName) {
    super(itemID, itemName);
}

public int compareTo(ComparableItem another) {
     if (this.score == another.score)
        return this.getItemName().compareTo(another.getItemName());
     else if ((this.score) > another.score)
        return 1;
     else
        return -1;
}

public abstract boolean found(String criteria);

And this is the MenuListItem class :

public class MenuListItem {

private String itemID,itemName;

public MenuListItem(String itemID, String itemName){
    setItemID(itemID);
    setItemName(itemName);
}

public String getItemID() {
    return itemID;
}

public void setItemID(String itemID) {
    this.itemID = itemID;
}

public String getItemName() {
    return itemName;
}

public void setItemName(String itemName) {
    this.itemName = itemName;
}

@Override
public String toString() {
    return this.itemName;
}

Answer 1

Quote from the Java API of Comparable<T>:

The natural ordering for a class C is said to be consistent with
equals if and only if (e1.compareTo((Object)e2) == 0) has the same
boolean value as e1.equals((Object)e2) for every e1 and e2 of class C.

And for using compareTo, the api further says:

It is strongly recommended (though not required) that natural
orderings be consistent with equals. This is so because sorted sets
(and sorted maps) without explicit comparators behave “strangely” when
they are used with elements (or keys) whose natural ordering is
inconsistent with equals. In particular, such a sorted set (or sorted
map) violates the general contract for set (or map), which is defined
in terms of the equals method.

So you should probably override equals to be consistent with your compareTo(), because otherwise two different objects e1 and e2 with equal score and getItemName() will have e1.compareTo((Object)e2) == 0) but not e1.equals((Object)e2).