overriding compareTo()

[Adam Johnson]

In Core Java book volume one, there is this tip:

The compareTo method of the Comparable interface returns an integer. If the objects are not equal, it does not matter what negative or positive value you return. This flexibility can be useful when comparing integer fields. For example, suppose each employee has a unique integer id, and you want to sort by employee ID number. Then you can simply return id - other.id. That value will be some negative value if the first ID number is less than the other, 0 if they are the same ID, and some positive value otherwise. However, there is one caveat: The range of the integers must be small enough that the subtraction does not overflow. If you know that the IDs are not negative or that their absolute value is at most(Integer.MAX_VALUE - 1) / 2, you are safe.

i got everything in the tip except this part

that their absolute value is at most(Integer.MAX_VALUE - 1) / 2

What do they mean by that?

Thanks

[Martin Vashko]

This is the reason:

    public static void main(String[] argv) {
        int large = Integer.MAX_VALUE - 10;
        int small = Integer.MIN_VALUE + 10;
        int compare = large - small;
        System.out.println(compare);
    }

If the condition mentioned does not hold, you can subtract smaller value from the larger one and still get negative number, due to arithmetic overflow.

[Adam Johnson]

Thank you Martin for your answer

But lets say we change the code to

                int large = Integer.MAX_VALUE;
		int small = Integer.MIN_VALUE + 1;
		int compare = large - small;
		System.out.println(compare);

so large becomes 2147483647 and small is -2147483647 obviously the result should be 0, but instead it yields -2

How is that possible?

I know that when we add 1 to Integer.MAX_VALUE we get -2147483648 hence it overflow the variable by 1.

but in the subtraction case above shouldn't it go back to 0 position?

[Campbell Ritchie]

Welcome to the Ranch

This is a standard problem with integer arithmetic called overflow; you can overflow positively or negatively. The largest number you can fit into two's complement arithmetic in 8 bits is 0111_1111 (decimal = +127), but if you add 1 you get 1000_0000, which in two's complement is -128. Similarly if you subtract 1 from 1000_0000 (-128) you get 0111_1111 (+127).

[Rob Spoor]

Adam Johnson wrote:so large becomes 2147483647 and small is -2147483647 obviously the result should be 0, but instead it yields -2

large + small == 0. large - small == 2147483647 - -2147483647 == 2147483647 + 2147483647 == 4294967294. Since ints can only range from -2147483648 to 2147483647 this number overflows to -2.

For comparing ints I usually use the following:

return (value1 < value2 ? -1 : (value1 > value2 ? 1 : 0));

In other words, -1 if value1 < value2, 1 if value1 > value2 and 0 if value1 == value2.

[Adam Johnson]

Campbell and Rob thank you for your explanation

Rob Nice technique for handling comparison using the ternary operator

Adam