Why Java’s Float and Double Lose Precision and How BigDecimal Fixes It

We all know that floating‑point variables lose precision during calculations. The article shows a Java example where adding 0.05 and 0.01 yields 0.060000000000000005, illustrating the problem for monetary calculations.

Float has 6‑7 significant digits, double 15‑16. To avoid such errors, Java’s BigDecimal class is recommended.

API

Constructors:

BigDecimal(int)       // from int
BigDecimal(double)    // from double (may lose precision)
BigDecimal(long)      // from long
BigDecimal(String)    // from string (exact)

Methods:

add(BigDecimal)       // addition
subtract(BigDecimal)  // subtraction
multiply(BigDecimal)  // multiplication
divide(BigDecimal)    // division
toString()
doubleValue()
floatValue()
longValue()
intValue()

Even BigDecimal(double) can lose precision, as shown by a demo where constructing from double yields 2.030000000000000026645… while using the String constructor yields the exact 2.03.

The JDK source notes that the double constructor’s result is unpredictable because many decimal fractions cannot be represented exactly in binary. The recommended way is to convert the double to a string first or use BigDecimal.valueOf(double).

Correct Usage

Since BigDecimal objects are immutable, arithmetic operators cannot be used; you must call the provided methods with other BigDecimal instances.

A utility class BigDecimalUtil is presented, offering static methods add, sub, mul, and div that accept double arguments, convert them to BigDecimal via Double.toString, and perform precise operations.