How to use BigInteger class in Java

Some time we need to store some really big numbers. Though we are already using the primitive data types int and long. But sometime we need to store values which cannot be held by these data type.

We will understand the problem with the help of factorial calculation as follows:

If we are calculating factorial of 13 or more and will try to store it in int datatype then we will not get the correct result, and this will result in overflow.

Again if we are calculating factorial of 21 or more it cannot be held through long data type. It will give the same error as mentioned above.

To hold the factorial of 21 or more we need BigInteger class of java.math package. As name suggests BigInteger class is used to hold the really big number, something which is even bigger than maximum value of long primitive

e.g. 2^63 -1 or 9223372036854775807L. The java.math.BigInteger class provides all the operation similar to Java’s integer primitive and have all the relevant methods from Java.Math.

To declare a BigInteger we use:

BigInteger number = BigInteger.valueOf(long number);

Also worth noting that, similar to java.lang.String and other wrapper classes BigInteger is also Immutable in Java, which means its important to store result back into same variable, otherwise result of calculation will be lost. BigInteger stores numbers as 2's complement number like int primitive and support operation supported by int variables and all relevant methods from java.lang.Math class. Additionally it also provide support for modular arithmetic, bit manipulation, primality testing, prime generation, GCD calculation and other miscellaneous operations.

Important things about BigInteger class in Java

BigInteger class in Java is designed to deal with really large numbers in Java, but to do that it’s very important that you make yourself familiar with class. Here are some key points about java.math.BigInteger class :

1. The BigInteger class is used to represent arbitrarily large numbers. Overflow doesn't occur as is the case with int and long primitive.

2. The BigInteger class is immutable which means that the object on which the multiply function was invoked doesn't change the integer it is holding. The multiplication is performed and a new BigInteger is returned which needs to be stored in the variable fact.

3. BigInteger provides operations similar to int primitive type in Java, additionally it provide support for prime generation, bit manipulation, GCD calculations etc.

4. You can create BigInteger object by giving number as String or byte array using constructor, or you can convert a long value to BigInteger using valueOf() method as shown below :

BigInteger bigIntegerFromLong = BigInteger.valueOf(292909333L);
BigInteger bigIntegerFromString = new BigInteger("338948938948");

Java Program to Calculate Factorial of Large Number

Here is our sample Java program to calculate factorial for large numbers, well given number is not exactly large but the factorial value is definitely large. For example, factorial of 45 is 119622220865480194561963161495657715064383733760000000000, which is clearly out of bound for even a long data type. Since theoretically BigInteger has no limit it can hold these values as shown in following example.

There are many ways to calculate factorial like using recursion, dynamic programming or iteration. In following example we have used iteration to calculate factorial in Java.

import java.math.BigInteger;

/**
 * Write a Java program to calculate factorial of large numbers using
 * BigInteger.
 *
 * @author RD
 *
 */
public class LargeFactorialDemo {

    public static void main(String args[]) {

        System.out.printf("Factorial of 32 is %s %n", factorial(32));
        System.out.printf("Factorial of 0 is %s %n", factorial(0));
        System.out.printf("Factorial of 1 is %s %n", factorial(1));
        System.out.printf("Factorial of 5 is %s %n", factorial(5));
        System.out.printf("Factorial of 41 is %s %n", factorial(41));
        System.out.printf("Factorial of 45 is %s %n", factorial(45));

    }

    /*
     * Java method to calculate factorial of a large number
     * @return BigInteger factorial of given number
     */
    public static BigInteger factorial(int number) {
        BigInteger factorial = BigInteger.ONE;

        for (int i = number; i > 0; i--) {
            factorial = factorial.multiply(BigInteger.valueOf(i));
        }

        return factorial;
    }

}

Output
Factorial of 32 is 263130836933693530167218012160000000
Factorial of 0 is 1
Factorial of 1 is 1
Factorial of 5 is 120
Factorial of 41 is 33452526613163807108170062053440751665152000000000
Factorial of 45 is 119622220865480194561963161495657715064383733760000000000

You can see that how large factorial of 45 is, clearly its not possible to use long data type to store such huge integral values. You need to use BigInteger class to store such big values.

Hope you liked the post. Please consider leaving a comment and follow the blog.