Large numbers
Navigate Language Fundamentals topic: ) 
The integer primitive type with the largest range of value is the long
, from 2^{63} to 2^{63}1. If you need greater or lesser values, you have to use the BigInteger
class in the package java.math
. A BigInteger
object can represent any integer (as large as the RAM on the computer can hold) as it is not mapped on a primitive type. Respectively, you need to use the BigDecimal
class for great decimal numbers.
However, as these perform much slower than primitive types, it is recommended to use primitive types when it is possible.
BigInteger[edit  edit source]
The BigInteger
class represents integers of almost any size. As with other objects, they need to be constructed. Unlike regular numbers, the BigInteger
represents an immutable object  methods in use by the BigInteger
class will return a new copy of a BigInteger
.
To instantiate a BigInteger
, you can create it from either byte array, or from a string. For example:
Code section 3.23: 1 quintillion, or 10^18. Too large to fit in a long.
BigInteger i = new BigInteger("1000000000000000000");

BigInteger
cannot use the normal Java operators. They use the methods provided by the class.
Code section 3.24: Multiplications and an addition.
BigInteger a = new BigInteger("3");
BigInteger b = new BigInteger("4");
// c = a^2 + b^2
BigInteger c = a.multiply(a).add(b.multiply(b));

It is possible to convert to a long
, but the long
may not be large enough.
Code section 3.25: Conversion.
BigInteger aBigInteger = new BigInteger("3");
long aLong = aBigInteger.longValue();

BigDecimal[edit  edit source]
The BigInteger
class cannot handle decimal numbers. The BigDecimal
class represents a floating point value of arbitrary precision. It is composed of both a BigInteger
, and a scale value (represented by a 32bit integer).