java: how for loop work in the case of BigInteger

This could work

BigInteger i;
        for(i = BigInteger.valueOf(0);i.compareTo(new BigInteger("100000")) 
            <=0;i=i.add(BigInteger.ONE))
        {
            System.out.println(i);
        }

(or)

for(BigInteger i = BigInteger.valueOf(0);i.compareTo(new BigInteger("100000")) 
            <=0;i=i.add(BigInteger.ONE))
        {
            System.out.println(i);
        }

Note that don't declare BigInteger twice.


You use these syntax instead:

BigInteger i = BigInteger.valueOf(100000L);  // long i = 100000L;
i.compareTo(BigInteger.ONE) > 0              // i > 1
i = i.subtract(BigInteger.ONE)               // i = i - 1

So here's an example of putting it together:

    for (BigInteger bi = BigInteger.valueOf(5);
            bi.compareTo(BigInteger.ZERO) > 0;
            bi = bi.subtract(BigInteger.ONE)) {

        System.out.println(bi);
    }
    // prints "5", "4", "3", "2", "1"

Note that using BigInteger as a loop index is highly atypical. long is usually enough for this purpose.

API links

  • java.math.BigInteger
    • int compareTo(BigInteger val) from interface Comparable<T>
    • BigInteger subtract(BigInteger val)
    • BigInteger add(BigInteger val)
    • static BigInteger valueOf(long val)

The compareTo idiom

From the documentation:

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.

In other words, given BigInteger x, y, these are the comparison idioms:

x.compareTo(y) <  0     // x <  y
x.compareTo(y) <= 0     // x <= y
x.compareTo(y) != 0     // x != y
x.compareTo(y) == 0     // x == y
x.compareTo(y) >  0     // x >  y
x.compareTo(y) >= 0     // x >= y

This is not specific to BigInteger; this is applicable to any Comparable<T> in general.

Note on immutability

BigInteger, like String, is an immutable object. Beginners tend to make the following mistake:

String s = "  hello  ";
s.trim(); // doesn't "work"!!!

BigInteger bi = BigInteger.valueOf(5);
bi.add(BigInteger.ONE); // doesn't "work"!!!

Since they're immutable, these methods don't mutate the objects they're invoked on, but instead return new objects, the results of those operations. Thus, the correct usage is something like:

s = s.trim();
bi = bi.add(BigInteger.ONE);

I think this code should work

public static void main(String[] args) {
    BigInteger bigI = new BigInteger("10000000");
    BigInteger one = new BigInteger("1");

    for (; bigI.compareTo(one) == 0; bigI.subtract(one)) {
       bigI = bigI.add(one);
    }
}

Well, first of all, you have two variables called "i".

Second, where's the user input?

Third, i=i+i unboxes i into a primitive value, possibly overflowing it, and boxes the result in a new object (that is, if the statement even compiles, which I haven't checked).

Fourth, i=i+i can be written as i = i.multiply(BigInteger.valueof(2)).

Fifth, the loop is never run, because 100000 <= 1 is false.

Tags:

Java

Biginteger

Recent Posts