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.

## BigIntegerEdit

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.
```
1 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.
```
1 BigInteger a = new BigInteger("3");
2 BigInteger b = new BigInteger("4");
3
4 // c = a^2 + b^2
5 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.
```
1 BigInteger aBigInteger = new BigInteger("3");
2 long aLong = aBigInteger.longValue();
``` |

## BigDecimalEdit

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 32-bit integer).