Mastering Java’s BigDecimal: Avoid Precision Pitfalls and Write Accurate Calculations

Environment: Java 8

1. Preface

Accurate numerical computation is crucial in many applications, but floating‑point representation can cause precision problems. Java provides the BigDecimal class for high‑precision calculations. This article introduces BigDecimal and how to use it effectively.

2. Why Use BigDecimal

BigDecimal offers exact decimal representation and controllable rounding, eliminating the rounding errors typical of binary floating‑point arithmetic.

Typical scenarios include:

Financial calculations : ensures accurate monetary results.

Business calculations : avoids rounding errors in currency operations.

Scientific/engineering calculations : provides the precision required for scientific data.

Database operations : prevents precision loss when storing numeric types.

3. BigDecimal Pitfalls

When using BigDecimal , you may encounter the following issues:

Floating‑point precision : primitive double calculations can produce unexpected results, e.g., double d = 0.1 + 0.2; prints 0.30000000000000004 . Using BigDecimal with string constructors avoids this.

<code>double d = 0.1 + 0.2;
System.out.println(d);
</code>

Output:

<code>0.30000000000000004</code>

Using BigDecimal directly:

<code>BigDecimal d1 = new BigDecimal(0.1);
BigDecimal d2 = new BigDecimal(0.2);
System.out.println(d1.add(d2));
</code>

Output:

<code>0.3000000000000000166533453693773481063544750213623046875</code>

Correct usage with string arguments or valueOf :

<code>BigDecimal d1 = new BigDecimal("0.1");
BigDecimal d2 = new BigDecimal("0.2");
// or
BigDecimal d1 = BigDecimal.valueOf(0.1);
</code>

Equality and Comparison

Comparing two BigDecimal objects with equals also checks scale, so new BigDecimal("0.01") and new BigDecimal("0.010") are not equal:

<code>BigDecimal a = new BigDecimal("0.01");
BigDecimal b = new BigDecimal("0.010");
System.out.println(a.equals(b));
</code>

Output:

<code>false</code>

Use compareTo for value comparison:

<code>BigDecimal a = new BigDecimal("0.01");
BigDecimal b = new BigDecimal("0.010");
System.out.println(a.compareTo(b));
</code>

Output:

<code>0</code>

Non‑terminating Division

Dividing numbers that produce a non‑terminating decimal (e.g., 1 ÷ 3) throws an ArithmeticException unless a scale and rounding mode are specified:

<code>BigDecimal a = new BigDecimal("1");
BigDecimal b = new BigDecimal("3");
System.out.println(a.divide(b));
</code>

Output:

<code>Exception in thread "main" java.lang.ArithmeticException: Non-terminating decimal expansion; no exact representable decimal result.</code>

Correct approach with rounding:

<code>BigDecimal a = new BigDecimal("1");
BigDecimal b = new BigDecimal("3");
BigDecimal res = a.divide(b, 2, RoundingMode.HALF_UP);
System.out.println(res);
</code>

Output:

<code>0.33</code>

Printing Without Scientific Notation

Using toString() on a large BigDecimal may produce scientific notation:

<code>BigDecimal a = BigDecimal.valueOf(15934433455478719.11342234536624572202);
System.out.println(a.toString());
</code>

Output:

<code>3.563453525545672E+16</code>

Use toPlainString() to obtain a plain decimal representation:

<code>BigDecimal a = BigDecimal.valueOf(15934433455478719.11342234536624572202);
System.out.println(a.toPlainString());
</code>

Operation Order Matters

Multiplying then dividing can yield a different result than dividing then multiplying:

<code>BigDecimal a = BigDecimal.valueOf(1);
BigDecimal b = BigDecimal.valueOf(3);
BigDecimal c = BigDecimal.valueOf(3);
System.out.println(a.divide(b, 2, RoundingMode.HALF_UP).multiply(c)); // 0.99
System.out.println(a.multiply(c).divide(b, 2, RoundingMode.HALF_UP)); // 1.00
</code>

Therefore, be mindful of calculation order.

Finished!