Java Notes

java.math.BigInteger

Unbounded range. To work with integers that are larger than 64 bits (the size of a long), use java.math.BigInteger. This class represents unbounded integers and provides a number of methods for doing arithmetic with them.

Overflow in standard arithmetic. The problem with arithmetic using ints (or longs) is that, if the value becomes too large, Java saves only the low order 32 (64 for longs) bits and throws the rest away. For example, we can use the maximum value that can be stored in an int as an example. Both of the following operations can't possibly fit into an int, but the arithmetic doesn't produce an error, it produces a result!

  1 
  2 
  3 
  4 
  5 
  6 
  7 
  8 
  9 
 10 
 11 
 12 
 13 
 14 
 15 
 16 
 17 
 18 
 19 
 20 
 21 

//  numbers/TestOverflow.java -- Show int overflow and BigInteger solution.
//  Fred Swartz - 2004-12-03

import java.math.BigInteger;

public class TestOverflow {
    public static void main(String[] args) {
        int bad = 2000000000;     //Close to int max value.
        System.out.println("bad     = " + bad);
        System.out.println("bad + 1 = " + (bad + 1));
        System.out.println("bad * 3 = " + (bad * 3));
        System.out.println("bad * 4 = " + (bad * 4));
        
        BigInteger good = BigInteger.valueOf(2000000000);
        System.out.println();
        System.out.println("good     = " + good);
        System.out.println("good.add(BigInteger.ONE) = " + good.add(BigInteger.ONE));
        System.out.println("good.multiply(BigInteger.valueOf(3)) = " + good.multiply(BigInteger.valueOf(3)));
        System.out.println("good.multiply(BigInteger.valueOf(4)) = " + good.multiply(BigInteger.valueOf(4)));
    }
}

Produces this output. If a result exceeds Integer.MAX_VALUE (2,147,483,647), the result will be wrong, but Java doesn't report an error! The BigInteger results are correct. But you do have to put up was some seriously ugly syntax.

bad     = 2000000000
bad + 1 = 2000000001
bad * 3 = 1705032704   // Smaller?
bad * 4 = -589934592   // Negative?!!!  Overflowed into sign bit.

good     = 2000000000
good.add(BigInteger.ONE) = 2000000001
good.multiply(BigInteger.valueOf(3)) = 6000000000
good.multiply(BigInteger.valueOf(4)) = 8000000000

Omitted features. BigInteger methods ignored in this summary: bit operations, random numbers, and prime testing.

Example

See Example - Factorial for a use of BigInteger.

Constructors and Methods

Assume

BigInteger bi, bi1, bi2, bi3, bi4;
BigInteger[] bia;  // array holding division result and remainder.
String s; int  i; long lng; float f; double d;