BigInteger
- Represents integers of arbitrary size.
- There is no limit to the size of the number.
- It is used for operations requiring precision and security, such as cryptography and complex numerical calculations.
- It provides methods for performing arithmetic operations, such as addition, subtraction, multiplication, division, and modulo.
- It is immutable, meaning that once created, its value cannot change.
BigDecimal
- Represents decimal numbers of arbitrary size with defined precision and scale.
- Allows you to control the precision and scale of decimal numbers.
- It is used for financial, scientific, and engineering operations that require precision and control over decimals.
- Provides methods for performing arithmetic operations, such as addition, subtraction, multiplication, division, and rounding.
- It is immutable, meaning that once created, its value cannot change.
BigInteger is used for very large integers, while BigDecimal is used for decimal numbers with defined precision and control. Both classes are essential for performing accurate and reliable numerical calculations in Java.
BigDecimal can be considered an extension of BigInteger.
BigInteger is a special case of BigDecimal: A BigInteger can be viewed as a BigDecimal with scale 0 (i.e., no decimal places).
BigDecimal can represent integers: A BigDecimal can represent integers without decimals, meaning it can perform the same operations as a BigInteger.
BigDecimal inherits functionality from BigInteger: The BigDecimal class inherits some functionality from BigInteger, such as the ability to perform arithmetic operations and handling large numbers.
BigDecimal has higher complexity: Because BigDecimal handles decimal numbers, it has higher complexity than BigInteger and requires more resources to perform operations.
BigInteger is more efficient for integers: If you only need to work with integers, BigInteger is more efficient and faster than BigDecimal.
Although BigDecimal can be considered an extension of BigInteger, each class has its own features and advantages.
convert biginteger to BigDecimal:
BigInteger bigInt = ...; // bigInt value
BigDecimal bigDec = new BigDecimal(bigInt);Differences between double and BigDecimal
Precision
- double: Has a precision of approximately 15 decimal places. This can lead to rounding errors in financial or scientific calculations.
- BigDecimal: Offers arbitrary precision, meaning it can represent decimal numbers with an unlimited number of digits.
Representation
- double: Uses a binary floating-point representation, which can introduce rounding errors when converting decimal numbers to binary.
- BigDecimal: Stores decimal numbers as a string of digits, which prevents rounding errors.
Performance
- double: It is faster and more efficient in terms of performance, as it uses the processor’s native arithmetic operations.
- BigDecimal: It is slower than double due to the complexity of the arithmetic operations and precision management.
Differences between int and BigInteger
Range of values
- int: Has a range of values limited to -2,147,483,648 to 2,147,483,647.
- BigInteger: Can represent arbitrarily large integers, with no practical limits.
Arithmetic operations
- int: Arithmetic operations with int can cause overflows if the result exceeds the range of allowed values.
- BigInteger: Arithmetic operations with BigInteger are unlimited and can handle very large numbers without overflows.
Performance
- int: It is faster and more efficient in terms of performance, as it uses the processor’s native arithmetic operations.
- BigInteger: It is slower than int due to the complexity of the arithmetic operations and the management of large number representations.
- Use double when you need to perform scientific or mathematical calculations that don’t require high precision.
- Use BigDecimal when you need to perform financial or precise calculations that require high precision.
- Use int when you need to perform arithmetic operations on integers within the allowed range.
- Use BigInteger when you need to perform arithmetic operations on very large integers that exceed the range allowed by int.
Instantiating BigInteger
From a string
BigInteger bigInteger = new BigInteger("12345678901234567890");From an int
int var = 123456789;
BigInteger bigInteger = BigInteger.valueOf(var);From a long
long var = 1234567890123456789L;
BigInteger bigInteger = BigInteger.valueOf(var);From a byte array
byte[] bytes = {1, 2, 3, 4, 5};
BigInteger bigInteger = new BigInteger(bytes);Instantiating BigDecimal
From a string
BigDecimal bigDecimal = new BigDecimal("123.45678901234567890");From a double
double var = 123.45678901234567890;
BigDecimal bigDecimal = new BigDecimal(var);
// Note: When instantiating from a double, decimals may be lost due to binary representation.From a long
long var = 1234567890123456789L;
BigDecimal bigDecimal = BigDecimal.valueOf(var);From an int
int var = 123456789;
BigDecimal bigDecimal = BigDecimal.valueOf(var);From a BigInteger and an int (scale)
BigInteger bigInteger = new BigInteger("12345678901234567890");
int scale = 10;
BigDecimal bigDecimal = new BigDecimal(bigInteger, scale);bigdecimal to double:
BigDecimal bigDecimal = new BigDecimal("123.456");
double doubleValue = bigDecimal.doubleValue();Converting BigDecimal to double may lose precision
double to BigDecimal:
double doubleValue = 123.456;
BigDecimal bigDecimal = BigDecimal.valueOf(doubleValue);Converting from double to BigDecimal using BigDecimal.valueOf() may result in an exact representation