Java, comparing BigInteger values

Question

BigInteger bigInteger = ...;


if(bigInteger.longValue() > 0) {  //original code
    //bigger than 0
}

//should I change to this?
if(bigInteger.compareTo(BigInteger.valueOf(0)) == 1) {
    //bigger than 0
}

I need to compare some arbitary BigInteger values. I wonder which approach is correct. Given the above code which one should be used? The original code is on the top.. I am thinking to change it to the second approach.

score 41 · Accepted Answer · edited May 23 '17 at 10:30

41

The first approach is wrong if you want to test if the BigInteger has a postive value: longValue just returns the low-order 64 bit which may revert the sign... So the test could fail for a positive BigInteger.

The second approach is better (see Bozhos answer for an optimization).

Another alternative: BigInteger#signum returns 1 if the value is positive:

if (bigInteger.signum() == 1) {
 // bigger than 0
}

edited May 23 '17 at 10:30

Community

1
1

answered Nov 04 '10 at 08:52

Andreas Dolk

113,398
19
180
268

thanks for the tip, but you mean `bigger _than_ 0` right? Just nitpicking.. :p – Rosdi Kasim Nov 04 '10 at 14:49
15

@Rosdi - sure, "than". Somatimas tha 'e' end tha 'a' kay chenga plecas on my kayboerd ;-) – Andreas Dolk Nov 04 '10 at 15:27

Bozho · Answer 2 · 2010-11-04T09:12:29.643

31

If you are using BigInteger, this assumes you need bigger numbers than long can handle. So don't use longValue(). Use compareTo. With your example it better be:

if (bigInteger.compareTo(BigInteger.ZERO) > 0) {

}

edited Nov 04 '10 at 09:12

answered Nov 04 '10 at 08:51

Bozho

588,226
146
1,060
1,140

6

True (+1), but check for ` > 0`, not `== 1` (see my answer) – Sean Patrick Floyd Nov 04 '10 at 09:12
@seanizer - just fixed that, and +1 to your answer for which. – Bozho Nov 04 '10 at 09:12

Sean Patrick Floyd · Answer 3 · 2010-11-04T15:01:56.460

This is not a direct answer, but an important note about using compareTo().

When checking the value of compareTo(), always test for x < 0, x > 0 and x == 0.
Do not test for x == 1

From the Comparable.compareTo() javadocs:

Compares this object with the specified object for order. Returns a negative integer, zero, or a positive integer as this object is less than, equal to, or greater than the specified object.

Note:

A negative integer, not -1.
A positive integer, not 1.

True, checking for ==1 and ==-1 would work for BigInteger. This is the BigInteger.compareTo() code:

public int compareTo(BigInteger val) {
    if (signum == val.signum) {
        switch (signum) {
        case 1:
            return compareMagnitude(val);
        case -1:
            return val.compareMagnitude(this);
        default:
            return 0;
        }
    }
    return signum > val.signum ? 1 : -1;
}

But it's still bad practice, and explicitly recommended against in the JavaDocs:

Compares this BigInteger with the specified BigInteger. This method is provided in preference to individual methods for each of the six boolean comparison operators (<, ==, >, >=, !=, <=). The suggested idiom for performing these comparisons is: (x.compareTo(y) <op> 0), where <op> is one of the six comparison operators.

The spec for `BigInteger.compareTo()` does explicitly say `-1, 0, and 1` but I do agree using `x < 0`, `x == 0`, `x > 0` feels more intuitive rather than `x == -1`, `x == 0`, `x == 1`. — Rosdi Kasim, Nov 04 '10 at 14:53
@Rosdi but it also says *The suggested idiom for performing these comparisons is: (`x.compareTo(y) 0`), where `` is one of the six comparison operators.* — Sean Patrick Floyd, Nov 04 '10 at 14:56

Java, comparing BigInteger values

3 Answers3

Linked