Java BigInteger Class

What is a BigInteger Class?

There are some primitive data types in Java that are used, such as int or long, to perform integer operations. However, sometimes we need to store large numbers outside the scope of such primitive data types. BigInteger Class is used for mathematical computations for very large numbers. It provides all methods from the java.lang.Math package and analogues to all of the Java’s primitive integer operators. BigInteger Class covers operations for modular arithmetic, bit manipulation, GCD calculation, and a few other operations. BigIntegers are represented in two’s-complement notation. There is no theoretical limit on how large a number can be stored because the memory is allocated dynamically. However, practically the memory is limited and we can store an integer that has the number of bits less than or equal to the Integer.MAX_VALUE. This provides a sufficiently large upper bound to store practically almost all large numbers.

How is the BigInteger Class Implemented?

import java.math.BigInteger;

To implement the BigInteger class in your code, you need to import java.math.BigInteger package.

BigInteger Class Declaration

The BigInteger class in Java is declared in the following way in java.math package:

public class BigInteger
   extends Number
      implements Comparable<BigInteger>

The BigInteger class extends the Number class and implements a Comparable interface. It is declared and defined in java.math package.

Class Constructors

Java’s BigInteger Class has many overloaded constructors. You may try and run each in the editor to see how they work.

Class Methods

Java’s BigInteger class has many methods, some of which are described below. In the table, ‘this’ represents the BigInteger that calls the method and ‘val’ is the argument passed to the method.

Example 1

import java.math.BigInteger;
public class Example1 {
    static BigInteger calculateFactorial(int val) {
        // Initialize result
        BigInteger f = BigInteger.ONE; // Or new BigInteger("1")
        // compute factorial
        for (int i = 2; i <= val; i++) {
            f = f.multiply(BigInteger.valueOf(i));
        }

        return f;
    }

    // Driver method
    public static void main(String[] args) {
        int val = 25;
        System.out.println(calculateFactorial(val));
    }
}

Output

Explanation

In the snippet above, the factor of a large number is calculated using BigInteger Class by importing java.math.BigInteger package. We have created a calculateFactorial method. This method creates a BigInteger and then calculates the factorial by using the multiply method f.multiply(BigInteger.valueOf(i)).

Example 2

import java.math.BigInteger;
public class Example2 {

    public static void main(String[] args) {
        BigInteger big1 = new BigInteger("20");
        BigInteger big2 = new BigInteger("60");
        BigInteger sub = big2.subtract(big1);
        System.out.println(big2 + " - " + big1 + " = " + sub);
        BigInteger add = big1.add(big2);
        System.out.println(big1 + " + " + big2 + " = " + add);
        BigInteger mul = big1.multiply(big2);
        System.out.println(big1 + " * " + big2 + " = " + mul);
        BigInteger div = big2.divide(big1);
        System.out.println(big2 + " / " + big1 + " = " + div);
        BigInteger min = big1.min(big2);
        System.out.println("min value: " + min);
        BigInteger max = big1.max(big2);
        System.out.println("max value: " + max);
    }
}

Output

Explanation

In the snippet above, we have made two BigIntegers using the BigInteger(String val) constructor. We applied different methods on the BigIntegers big1 and big2 with the values 20 and 60 respectively. We applied the following methods:

1. big2.subtract(big1) to subtract 20 from 60.
2. big1.add(big2) to add 20 and 60.
3. big1.multiply(big2) to multiply 20 and 60.
4. big2.divide(big1) to divide 60 by 20.
5. big1.min(big2) to get the smaller of the two values.
6. big1.max(big2) to get the larger of the two values.

It is important to note that java.math.BigInteger is imported at the top of the code.

Conclusion

By now you should be familiar with the BigInteger Class in Java. You should be able to use BigIntegers in your code using different types of constructors. You should also be able to perform different arithmetic and logical operations on them by using BigInteger Class methods. As a challenge, you can try calling different methods with different values of BigIntegers. It will further strengthen your understanding of BigIntegers in Java. To be more confident in your learning try practicing it over and over. The key to good coding is practice. Best of luck and happy coding!