Java Integer: what is faster comparison or subtraction?

Question

I've found that java.lang.Integer implementation of compareTo method looks as follows:

public int compareTo(Integer anotherInteger) {
int thisVal = this.value;
int anotherVal = anotherInteger.value;
return (thisVal<anotherVal ? -1 : (thisVal==anotherVal ? 0 : 1));
}

The question is why use comparison instead of subtraction:

return thisVal - anotherVal;

Answer 1

It has to do with Integer overflow errors. When thisVal is very large and anotherVal is negative then subtracting will yield a result that is bigger than thisVal which may overflow to be negative.

Answer 2

Perhaps it's to avoid overflow / underflow.

Answer 3

Simply speaking, the int type is not big enough to store the difference between two arbitrary int values. For example, the difference between 1.5 billion and -1.5 billion is 3.0 billion, but int cannot hold values greater than 2.1 billion.

Answer 4

In addition to the overflow thing, you should note that the version with substraction does not give the same results.

• The first compareTo version returns one of three possible values: -1, 0, or 1.
• If you replace the last line with substraction, the result can be any integer value.

If you know there will be no overflow, you could use something like this:

public int compareTo(Integer anotherInteger) {
    return sign(this.value - anotherInteger.valuel);
}