Java BigInteger: Arbitrary-Precision Arithmetic

java biginteger requires a clear understanding of the core syntax, runtime behavior, and practical implementation patterns demonstrated in the examples below.

When a calculation exceeds the range of long or double, Java's primitive types silently overflow or lose precision. java.math.BigInteger provides arbitrary-precision integer arithmetic, meaning it can represent any integer value limited only by available memory. This article covers the practical aspects of using BigInteger: constructing instances, performing arithmetic, converting to and from other types, and understanding the performance implications.

When Long and Double Are Not Enough

The long type holds values from -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807. Any operation that exceeds these bounds wraps around, producing incorrect results without an exception. For example, Long.MAX_VALUE + 1 yields Long.MIN_VALUE. Floating-point types like double lose precision for integers larger than 2^53 because they use a 52-bit mantissa. BigInteger solves this by storing numbers as an array of int values, each holding a portion of the magnitude, and a sign flag. This design allows it to grow dynamically as needed, at the cost of object allocation and slower arithmetic.

Creating BigInteger Instances

There is no literal syntax for BigInteger; you must construct it explicitly. The most common ways are:

BigInteger fromLong = BigInteger.valueOf(123456789L);
BigInteger fromString = new BigInteger("123456789012345678901234567890");
BigInteger fromByteArray = new BigInteger(new byte[] { 0x01, 0x02, 0x03 });

valueOf is efficient for small values because it caches instances for numbers between -16 and 16. The string constructor accepts an optional sign and decimal digits, and throws NumberFormatException if the string is malformed. The byte-array constructor interprets the bytes as a two's-complement integer, with the first byte as the most significant. For a byte array representing a positive number, ensure the leading byte is zero if the highest bit of the first byte is set, to avoid a negative interpretation.

Basic Arithmetic Operations

BigInteger is immutable; every arithmetic operation returns a new instance. The core methods mirror primitive operators:

BigInteger a = new BigInteger("100000000000000000000000000000");
BigInteger b = new BigInteger("200000000000000000000000000000");

BigInteger sum = a.add(b);
BigInteger diff = a.subtract(b);
BigInteger product = a.multiply(b);
BigInteger quotient = b.divide(a);
BigInteger remainder = b.mod(a);
BigInteger negated = a.negate();
BigInteger absolute = a.abs();

Division truncates toward zero, matching integer division in Java. The mod method always returns a non-negative result, while remainder can be negative. This distinction matters when working with negative operands. For example, (-7).mod(3) returns 2, while (-7).remainder(3) returns -1. Choose based on whether you need a mathematical modulus or a truncated remainder.

Comparing BigInteger Values

Because BigInteger overrides equals, you can compare for equality with equals, but it also implements Comparable<BigInteger>, so compareTo is the preferred method for ordering. The compareTo method returns a negative, zero, or positive integer depending on the relationship. Avoid using == because it compares object references, not values.

BigInteger x = BigInteger.valueOf(42);
BigInteger y = BigInteger.valueOf(42);
System.out.println(x.equals(y));      // true
System.out.println(x.compareTo(y));   // 0
System.out.println(x == y);           // false (unless cached, but not guaranteed)

For checking zero, use BigInteger.ZERO.equals(x) or x.signum() == 0. The signum method returns -1, 0, or 1, which is useful for quick sign checks.

Conversion and Round-Trip

Converting BigInteger to primitive types requires explicit methods because the value might not fit. The methods intValue(), longValue(), floatValue(), and doubleValue() truncate or lose precision silently. Use intValueExact(), longValueExact() to throw ArithmeticException if the value does not fit exactly. For conversions to strings, toString() returns the decimal representation. To get a byte array suitable for serialization, use toByteArray():

BigInteger big = new BigInteger("255");
byte[] bytes = big.toByteArray(); // [0, -1] because leading zero preserves sign
BigInteger roundTrip = new BigInteger(bytes);

When you need to store a BigInteger in a database or transmit it, converting to a string is often simplest. The string constructor is robust and human-readable. For binary protocols, toByteArray() is more compact but requires careful handling of the sign bit.

Performance and Memory Considerations

BigInteger operations are significantly slower than primitive arithmetic because they involve object allocation and digit-by-digit computation. The complexity of multiplication is O(n^2) for the naive algorithm, though Java uses Karatsuba and Toom-Cook for large numbers. In practice, if your values fit within long, use long instead. BigInteger is appropriate for cryptographic keys, large integer factorization, or exact decimal conversions where precision is non-negotiable.

Each BigInteger instance consumes memory proportional to the number of digits. Because operations return new instances, chaining many operations creates intermediate objects that the garbage collector must reclaim. In performance-sensitive loops, consider reusing variables and avoiding unnecessary conversions. For example, pre-compute constants as static final fields.

Common Pitfalls and Edge Cases

One frequent mistake is using new BigInteger("0") instead of BigInteger.ZERO. The cached constants ZERO, ONE, TEN are preallocated and avoid unnecessary allocation. Another pitfall is assuming divide and mod behave identically for negative numbers. As noted, mod always yields a non-negative result, which is useful for cyclic operations like hashing.

Division by zero throws ArithmeticException just like primitive division. Also, the shiftLeft and shiftRight methods operate on the two's-complement representation, so shifting negative numbers may produce unexpected signs. For bitwise operations, remember that BigInteger uses an infinite-length two's-complement representation internally, so not() flips all bits, including an infinite leading sign extension.

Thread Safety and Immutability

BigInteger is immutable, so instances can be safely shared across threads without synchronization. This is a significant advantage over mutable numeric wrappers. You can store a BigInteger in a final field and use it concurrently without worrying about data races. However, if you perform a sequence of operations that depend on each other, you must synchronize the entire sequence yourself, because each operation returns a new instance and the intermediate state is not shared.

Choosing Between BigInteger and Other Numeric Types

The decision to use BigInteger should be based on the range of values and the required precision. If the range is known and fits in long, use long for performance. If you need decimal fractions with fixed precision, BigDecimal is the appropriate class. For cryptographic applications, BigInteger is the standard choice for modular arithmetic and key generation. When working with arbitrary-precision integers in a library, expose BigInteger in your API to avoid forcing callers to lose precision. The key is to understand the tradeoff: BigInteger gives correctness at the cost of speed and memory, and it should be used only when the alternative is incorrect results.