# BigInteger in Java

By Arvind Rai, November 20, 2023
This page will walk through Java `BigInteger` tutorial with examples. `BigInteger` is an immutable arbitrary-precision integer. It performs the operations of `java.lang.Math` class and many more operations such as modular arithmetic, GCD calculation and prime generation etc. We can instantiate `BigInteger` and can access its value using following methods.
```BigInteger bint = new BigInteger("215");
bint.intValue();
bint.longValue();
bint.floatValue();
bint.doubleValue(); ```
Now find the examples for `BigInteger` methods in detail.

### 1. probablePrime()

`probablePrime()` returns a positive `BigInteger` that is probably prime. We need to pass bit length that will be the bit length of returned `BigInteger`. We will also pass instance of `Random` class.
ProbablePrimeDemo.java
```package com.concretepage;
import java.math.BigInteger;
import java.util.Random;
public class ProbablePrimeDemo {
public static void main(String[] args) {
BigInteger bint = BigInteger.probablePrime(8, new Random());
System.out.println("Probable Prime Number: "+ bint);
}
}```
Output
`Probable Prime Number: 223 `

### 2. nextProbablePrime()

It returns the next `BigInteger` that is probably prime. It never skips a prime number while looking for next prime number.
NextProbablePrimeDemo.java
```package com.concretepage;
import java.math.BigInteger;
import java.util.Random;
public class NextProbablePrimeDemo {
public static void main(String[] args) {
BigInteger bint = BigInteger.probablePrime(8, new Random());
System.out.println("Probable Prime Number: "+ bint);
System.out.println("Next Probable Prime Number: "+ bint.nextProbablePrime());
}
} ```
Output
```Probable Prime Number: 251
Next Probable Prime Number: 257 ```

### 3. isProbablePrime()

It returns true if value is probably prime otherwise false. We need to pass an integer value as certainty which is a measure of the uncertainty that the caller is willing to tolerate. If certainty is <=0, then the method `isProbablePrime()` will always return true.
IsProbablePrimeDemo.java
```package com.concretepage;
import java.math.BigInteger;
public class IsProbablePrimeDemo {
public static void main(String[] args) {
BigInteger bint1 = new BigInteger("195");
BigInteger bint2 = new BigInteger("197");
BigInteger bint3 = new BigInteger("190");
System.out.println("bint1.isProbablePrime(2):"+ bint1.isProbablePrime(2));
System.out.println("bint2.isProbablePrime(2):"+ bint2.isProbablePrime(2));
System.out.println("bint3.isProbablePrime(2):"+ bint3.isProbablePrime(2));
System.out.println("bint3.isProbablePrime(-2):"+ bint3.isProbablePrime(-2));
}
} ```
Output
```bint1.isProbablePrime(2):false
bint2.isProbablePrime(2):true
bint3.isProbablePrime(2):false
bint3.isProbablePrime(-2):true ```

`add()` method adds two `BigInteger` instances.
```package com.concretepage;
import java.math.BigInteger;
public static void main(String[] args) {
BigInteger bint = new BigInteger("234");
System.out.println("Result:" + bintRes);
}
} ```
Output
`Result:684 `

### 5. subtract()

`subtract()` method subtracts the given `BigInteger` from calling `BigInteger` instance.
SubtractDemo.java
```package com.concretepage;
import java.math.BigInteger;
public class SubtractDemo {
public static void main(String[] args) {
BigInteger bint = new BigInteger("500");
BigInteger bintRes = bint.subtract(new BigInteger("300"));
System.out.println("Result:" + bintRes);
}
} ```
Output
`Result:200 `

### 6. multiply()

`multiply()` multiplies two `BigInteger` instances.
MultiplyDemo.java
```package com.concretepage;
import java.math.BigInteger;
public class MultiplyDemo {
public static void main(String[] args) {
BigInteger bint = new BigInteger("50");
BigInteger bintRes = bint.multiply(new BigInteger("30"));
System.out.println("Result:" + bintRes);
}
} ```
Output
`Result:1500 `

### 7. divide()

`divide()` method divides the calling `BigInteger` by given `BigInteger` instance.
DivideDemo.java
```package com.concretepage;
import java.math.BigInteger;
public class DivideDemo {
public static void main(String[] args) {
BigInteger bint = new BigInteger("500");
BigInteger bintRes = bint.divide(new BigInteger("25"));
System.out.println("Result:" + bintRes);
}
} ```
Output
`Result:20 `

### 8. remainder()

It returns the `BigInteger` as remainder of the operation a % b.
RemainderDemo.java
```package com.concretepage;
import java.math.BigInteger;
public class RemainderDemo {
public static void main(String[] args) {
int a = 500;
int b = 28;
BigInteger bint = new BigInteger(String.valueOf(a));
BigInteger bintRes = bint.remainder(new BigInteger(String.valueOf(b)));
System.out.println("a % b: " + bintRes);
}
} ```
Output
`a % b: 24 `

### 9. divideAndRemainder()

It returns an array of `BigInteger` of the result of `divide()` and `remainder()` method for the two `BigInteger` instances.
DivideAndRemainderDemo.java
```package com.concretepage;
import java.math.BigInteger;
public class DivideAndRemainderDemo {
public static void main(String[] args) {
int a = 597;
int b = 20;
BigInteger bint = new BigInteger(String.valueOf(a));
BigInteger[] bintRes = bint.divideAndRemainder(new BigInteger(String.valueOf(b)));
System.out.println("a/b: " + bintRes[0]);
System.out.println("a % b: " + bintRes[1]);
}
} ```
Output
```a/b: 29
a % b: 17 ```

### 10. pow()

It calculates the power of a `BigInteger` value and returns a `BigInteger`. The exponent will be an integer.
PowDemo.java
```package com.concretepage;
import java.math.BigInteger;
public class PowDemo {
public static void main(String[] args) {
int exponent = 7;
BigInteger bint = new BigInteger("12");
BigInteger bintRes = bint.pow(exponent);
System.out.println("Result: " + bintRes);
}
} ```
Output
`Result: 35831808 `

### 11. gcd()

`gcd()` is greatest common divisor of absolute values of two `BigInteger` and returns a `BigInteger`.
GCDDemo.java
```package com.concretepage;
import java.math.BigInteger;
public class GCDDemo {
public static void main(String[] args) {
BigInteger bint1 = new BigInteger("24");
BigInteger bint2 = new BigInteger("40");
BigInteger bintRes = bint1.gcd(bint2);
System.out.println("GCD:" + bintRes);
}
} ```
Output
`GCD:8 `

### 12. abs()

It returns a `BigInteger` with absolute value of a given `BigInteger`.
AbsDemo.java
```package com.concretepage;
import java.math.BigInteger;
public class AbsDemo {
public static void main(String[] args) {
BigInteger bint1 = new BigInteger("-234");
System.out.println(bint1.abs());
BigInteger bint2 = new BigInteger("100");
System.out.println(bint2.abs());
}
} ```
Output
```234
100 ```

### 13. negate()

It returns a `BigInteger` with negative value of the original value.
NegateDemo.java
```package com.concretepage;
import java.math.BigInteger;
public class NegateDemo {
public static void main(String[] args) {
BigInteger bint1 = new BigInteger("-134");
System.out.println("negate() of -134 :"+bint1.negate());
BigInteger bint2 = new BigInteger("155");
System.out.println("negate() of 155 :" + bint2.negate());
}
} ```
Output
```negate() of -134 :134
negate() of 155 :-155 ```

### 14. signum()

It returns the signum function values of the `BigInteger`. Signum function value for negative values is -1 and signum function for 0 is 0 and signum function for positive value is +1.
SignumDemo.java
```package com.concretepage;
import java.math.BigInteger;
public class SignumDemo {
public static void main(String[] args) {
//-1 for values < 0
System.out.println("signum for -15: "+ new BigInteger("-15").signum());
//0 for value 0
System.out.println("signum for   0: "+ new BigInteger("0").signum());
//1 for values > 0
System.out.println("signum for  25: "+ new BigInteger("25").signum());
}
} ```
Output
```signum for -15: -1
signum for   0: 0
signum for  25: 1 ```

### 15. mod()

Modulus is the remainder of the Euclidean division . `mod()` always returns `BigInteger` with positive value whereas `remainder()` can return `BigInteger` with +ve and -ve values both. In this example we will use `mod()` and `remainder()` both to understand the differences between the two.
ModDemo.java
```package com.concretepage;
import java.math.BigInteger;
public class ModDemo {
public static void main(String[] args) {
System.out.println("32 mod 7= "+new BigInteger("32").mod(new BigInteger("7")));
System.out.println("32 % 7= "+ new BigInteger("32").remainder(new BigInteger("7")));

System.out.println("-32 mod 7= "+new BigInteger("-32").mod(new BigInteger("7")));
System.out.println("-32 % 7= "+ new BigInteger("-32").remainder(new BigInteger("7")));
}
} ```
Output
```32 mod 7= 4
32 % 7= 4
-32 mod 7= 3
-32 % 7= -4 ```

### 16. modPow()

This method first calculates `pow()` then applies `mod()`. Here exponent is a `BigInteger` and can have -ve value.
ModPowDemo.java
```package com.concretepage;
import java.math.BigInteger;
public class ModPowDemo {
public static void main(String[] args) {
BigInteger b = new BigInteger("-2");
BigInteger e = new BigInteger("3");
BigInteger m = new BigInteger("5");
BigInteger res= b.modPow(e, m);
System.out.println("b.modPow(e, m): " +res);
//The result is equivalent to below code
System.out.println("b.pow(e.intValue()).mod(m): " + b.pow(e.intValue()).mod(m));
}
} ```
Output
```b.modPow(e, m): 2
b.pow(e.intValue()).mod(m): 2 ```

### 17. modInverse()

`modInverse()` method will calculate modulus of the inverse of the given value as (this^-1 mod m). According to java doc, it will throw error if "BigInteger has no multiplicative inverse mod m (that is, this BigInteger is not relatively prime to m)."
ModInverseDemo.java
```package com.concretepage;
import java.math.BigInteger;
public class ModInverseDemo {
public static void main(String[] args) {
BigInteger b1 = new BigInteger("-13");
BigInteger b2 = new BigInteger("4");
System.out.println("b1.modInverse(b2): "+b1.modInverse(b2));
}
}```
Output
`b1.modInverse(b2): 3 `

### 18. compareTo()

This method compares the `BigInteger` with given ` BigInteger` and returns -1, 0 or 1 as this BigInteger is numerically less than, equal to, or greater than given value.
CompareToDemo.java
```package com.concretepage;
import java.math.BigInteger;
public class CompareToDemo {
public static void main(String[] args) {
System.out.println(new BigInteger("300").compareTo(new BigInteger("150")));
System.out.println(new BigInteger("200").compareTo(new BigInteger("350")));
System.out.println(new BigInteger("140").compareTo(new BigInteger("140")));
}
} ```
Output
```1
-1
0 ```

### 19. equals()

This method checks for equality of a `BigInteger` with a given `BigInteger`.
EqualsDemo.java
```package com.concretepage;
import java.math.BigInteger;
public class EqualsDemo {
public static void main(String[] args) {
System.out.println(new BigInteger("300").equals(new BigInteger("150")));
System.out.println(new BigInteger("140").equals(new BigInteger("140")));
}
} ```
Output
```false
true ```

### 20 min() and max()

`min()` returns the `BigInteger` with minimum value and `max()` returns the `BigInteger` with maximum value between the two `BigInteger` instances.
MinMaxDemo.java
```package com.concretepage;
import java.math.BigInteger;
public class MinMaxDemo {
public static void main(String[] args) {
System.out.println("Min: "+ new BigInteger("300").min(new BigInteger("150")));
System.out.println("Max: "+new BigInteger("300").max(new BigInteger("150")));
}
} ```
Output
```Min: 150
Max: 300 ```

### 21. Reference

Java Doc: Class BigInteger
POSTED BY
ARVIND RAI