The BigInteger class is used for mathematical operations involving large integers with magnitudes too large for primitive data types. For example 100-factorial is 158 digits – much larger than a long can represent. BigInteger provides analogues to all of Java’s primitive integer operators, and all relevant methods from java.lang.Math as well as few other operations.

## Initialization

The java.math.BigInteger class provides operations analogs to all of Java’s primitive integer operators and for all relevant methods from java.lang.Math. As the java.math package is not automatically made available you may have to import java.math.BigInteger before you can use the simple class name.

To convert long or int values to BigInteger use:

long longValue = Long.MAX_VALUE;

BigInteger valueFromLong = BigInteger.valueOf(longValue);

or, for integers:

int intValue = Integer.MIN_VALUE; // negative

BigInteger valueFromInt = BigInteger.valueOf(intValue);

which will widen the intValue integer to long, using sign bit extension for negative values, so that negative values will stay negative.

To convert a numeric String to BigInteger use:

String decimalString = "-1"; BigInteger valueFromDecimalString = new BigInteger(decimalString);

The following constructor is used to translate the String representation of a BigInteger in the specified radix into a BigInteger.

String binaryString = "10";

int binaryRadix = 2;

BigInteger valueFromBinaryString = new BigInteger(binaryString , binaryRadix);

Java also supports direct conversion of bytes to an instance of BigInteger. Currently only signed and unsigned big endian encoding may be used:

byte[] bytes = new byte[] { (byte) 0x80 };

BigInteger valueFromBytes = new BigInteger(bytes);

This will generate a BigInteger instance with value -128 as the first bit is interpreted as the sign bit.

byte[] unsignedBytes = new byte[] { (byte) 0x80 };

int sign = 1; // positive

BigInteger valueFromUnsignedBytes = new BigInteger(sign, unsignedBytes);

This will generate a BigInteger instance with value 128 as the bytes are interpreted as unsigned number, and the sign is explicitly set to 1, a positive number.

There are predefined constants for common values:

* BigInteger.ZERO — value of "0". * BigInteger.ONE — value of "1". * BigInteger.TEN — value of "10".

There’s also BigInteger.TWO (value of “2”), but you can’t use it in your code because it’s private.

### BigInteger Mathematical Operations Examples

BigInteger is in an immutable object, so you need to assign the results of any mathematical operation, to a new BigInteger instance.

Related Article: Comparing BigIntegers in Java

**Addition**: 10 + 10 = 20

BigInteger value1 = new BigInteger("10"); BigInteger value2 = new BigInteger("10"); BigInteger sum = value1.add(value2); System.out.println(sum);

**output**: 20

**Subtraction**: 10 – 9 = 1

BigInteger value1 = new BigInteger("10"); BigInteger value2 = new BigInteger("9"); BigInteger sub = value1.subtract(value2); System.out.println(sub);

**output**: 1

**Division**: 10 / 5 = 2

BigInteger value1 = new BigInteger("10"); BigInteger value2 = new BigInteger("5"); BigInteger div = value1.divide(value2); System.out.println(div);

**output**: 2

**Division**: 17/4 = 4

BigInteger value1 = new BigInteger("17"); BigInteger value2 = new BigInteger("4"); BigInteger div = value1.divide(value2); System.out.println(div);

**output**: 4

**Multiplication**: 10 * 5 = 50

BigInteger value1 = new BigInteger("10"); BigInteger value2 = new BigInteger("5"); BigInteger mul = value1.multiply(value2); System.out.println(mul);

**output**: 50

**Power**: 10 ^ 3 = 1000

BigInteger value1 = new BigInteger("10"); BigInteger power = value1.pow(3); System.out.println(power);

**output**: 1000

**Remainder**: 10 % 6 = 4

BigInteger value1 = new BigInteger("10"); BigInteger value2 = new BigInteger("6"); BigInteger power = value1.remainder(value2); System.out.println(power);

**output**: 4

**GCD**: Greatest Common Divisor (GCD) for 12and 18 is 6.

BigInteger value1 = new BigInteger("12"); BigInteger value2 = new BigInteger("18"); System.out.println(value1.gcd(value2));

**Output**: 6

**Maximum of two BigIntegers:**

BigInteger value1 = new BigInteger("10"); BigInteger value2 = new BigInteger("11"); System.out.println(value1.max(value2));

**Output**: 11

**Minimum of two BigIntegers:**

BigInteger value1 = new BigInteger("10"); BigInteger value2 = new BigInteger("11"); System.out.println(value1.min(value2));

**Output**: 10