Understanding Java BigDecimal: How It Guarantees Precision in Financial Calculations

In financial applications, precision is essential, so Java developers often use the BigDecimal class. This article explores why BigDecimal can guarantee that precision is not lost.

Class introduction – The key fields of BigDecimal are shown below:

public class BigDecimal extends Number implements Comparable
{
    // unscaled value
    private final BigInteger intVal;
    // scale (number of digits after the decimal point)
    private final int scale;
    // precision (optional, 0 if unknown)
    private transient int precision;
    // cached string representation
    private transient String stringCache;
    // compact long representation
    private final transient long intCompact;
}

Example usage – A simple JUnit test demonstrates adding two numbers:

@Test
public void testBigDecimal() {
    BigDecimal bigDecimal1 = BigDecimal.valueOf(2.36);
    BigDecimal bigDecimal2 = BigDecimal.valueOf(3.5);
    BigDecimal resDecimal = bigDecimal1.add(bigDecimal2);
    System.out.println(resDecimal);
}

Debugging after BigDecimal.valueOf(2.36) shows the internal fields being populated with the expected values.

add method analysis – The public add method delegates to overloaded private methods that handle different internal representations. The core logic is:

/**
 * Returns a BigDecimal whose value is (this + augend),
 * and whose scale is max(this.scale(), augend.scale()).
 */
public BigDecimal add(BigDecimal augend) {
    if (this.intCompact != INFLATED) {
        if (augend.intCompact != INFLATED) {
            return add(this.intCompact, this.scale, augend.intCompact, augend.scale);
        } else {
            return add(this.intCompact, this.scale, augend.intVal, augend.scale);
        }
    } else {
        if (augend.intCompact != INFLATED) {
            return add(augend.intCompact, augend.scale, this.intVal, this.scale);
        } else {
            return add(this.intVal, this.scale, augend.intVal, augend.scale);
        }
    }
}

The private static overload that works with long values performs scaling based on the difference between the two scales:

private static BigDecimal add(final long xs, int scale1, final long ys, int scale2) {
    long sdiff = (long) scale1 - scale2;
    if (sdiff == 0) {
        return add(xs, ys, scale1);
    } else if (sdiff < 0) {
        int raise = checkScale(xs, -sdiff);
        long scaledX = longMultiplyPowerTen(xs, raise);
        if (scaledX != INFLATED) {
            return add(scaledX, ys, scale2);
        } else {
            BigInteger bigsum = bigMultiplyPowerTen(xs, raise).add(ys);
            return (xs ^ ys) >= 0 ? new BigDecimal(bigsum, INFLATED, scale2, 0)
                                   : valueOf(bigsum, scale2, 0);
        }
    } else {
        int raise = checkScale(ys, sdiff);
        long scaledY = longMultiplyPowerTen(ys, raise);
        if (scaledY != INFLATED) {
            return add(xs, scaledY, scale1);
        } else {
            BigInteger bigsum = bigMultiplyPowerTen(ys, raise).add(xs);
            return (xs ^ ys) >= 0 ? new BigDecimal(bigsum, INFLATED, scale1, 0)
                                   : valueOf(bigsum, scale1, 0);
        }
    }
}

In the example, the method receives xs=236 , scale1=2 , ys=35 , and scale2=1 . Because the scale difference is 1, the smaller‑scale operand is multiplied by 10 (raising it to 350) before the integer addition, preserving exact precision.

The final overload simply adds the scaled long values and constructs a new BigDecimal with the appropriate scale:

private static BigDecimal add(long xs, long ys, int scale) {
    long sum = add(xs, ys);
    if (sum != INFLATED)
        return BigDecimal.valueOf(sum, scale);
    return new BigDecimal(BigInteger.valueOf(xs).add(ys), scale);
}

Conclusion – BigDecimal achieves loss‑free precision by converting decimal numbers to scaled long (or BigInteger) representations, performing integer arithmetic, and then applying the stored scale to produce the final result. The article also points to further documentation for usage considerations.