Java BigDecimal 解决浮点精度问题

1. 正确创建 BigDecimal 对象

核心原则：避免使用 BigDecimal(double) 构造方法（会继承 double 的精度偏差），优先使用以下两种方式：

代码示例：创建方式对比

public class BigDecimalCreateDemo {
    public static void main(String[] args) {
        // 错误方式：BigDecimal(double) 存在精度损失
        BigDecimal wrong1 = new BigDecimal(0.1);
        System.out.println(wrong1); // 输出 0.1000000000000000055511151231257827021181583404541015625

        // 正确方式 1：BigDecimal(String)
        BigDecimal correct1 = new BigDecimal("0.1");
        System.out.println(correct1); // 输出 0.1（精确）

        // 正确方式 2：BigDecimal.valueOf(double)
        BigDecimal correct2 = BigDecimal.valueOf(0.1);
        System.out.println(correct2); // 输出 0.1（精确）
    }
}

2. 核心运算方法（加减乘除）

BigDecimal 没有重载 +、-、*、/ 运算符，需通过实例方法完成运算，且除法运算必须指定舍入模式（避免除不尽时抛出异常）。

常用运算方法

代码示例：精确运算

import java.math.BigDecimal;
import java.math.RoundingMode;

public class BigDecimalCalcDemo {
    public static void main(String[] args) {
        // 1. 初始化精确数值
        BigDecimal a = new BigDecimal("0.1");
        BigDecimal b = new BigDecimal("0.2");
        BigDecimal c = new BigDecimal("3");

        // 2. 加法
        BigDecimal sum = a.add(b);
        System.out.println("0.1 + 0.2 = " + sum); // 输出 0.3（精确）

        // 3. 减法
        BigDecimal diff = new BigDecimal("1.0").subtract(new BigDecimal("0.9"));
        System.out.println("1.0 - 0.9 = " + diff); // 输出 0.1（精确）

        // 4. 乘法
        BigDecimal product = a.multiply(c);
        System.out.println("0.1 * 3 = " + product); // 输出 0.3（精确）

        // 5. 除法（除不尽时必须指定舍入模式）
        BigDecimal divide1 = new BigDecimal("1.0").divide(c, RoundingMode.HALF_UP);
        System.out.println("1.0 / 3 = " + divide1); // 输出 0.33333333333333333333（默认精度）

        // 6. 除法（指定小数位数和舍入模式）
        BigDecimal divide2 = new BigDecimal("1.0").divide(c, 2, RoundingMode.HALF_UP);
        System.out.println("1.0 / 3（保留 2 位） = " + divide2); // 输出 0.33（四舍五入）
    }
}

3. 关键配置：舍入模式（RoundingMode）

BigDecimal 提供 RoundingMode 枚举类定义取舍规则，常用场景（如金额计算）优先使用 HALF_UP（四舍五入），避免使用默认的 UNNECESSARY（除不尽时抛异常）。

常用舍入模式说明

四、BigDecimal 进阶用法

1. 精度控制与格式化

通过 setScale(int scale, RoundingMode mode) 手动设置小数位数，结合 DecimalFormat 格式化输出（如金额千分位、货币符号）。

代码示例：精度控制与格式化

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.DecimalFormat;

public class BigDecimalFormatDemo {
    public static void main(String[] args) {
        BigDecimal amount = new BigDecimal("12345.6789");

        // 1. 设置小数位数（保留 2 位，四舍五入）
        BigDecimal scaledAmount = amount.setScale(2, RoundingMode.HALF_UP);
        System.out.println("保留 2 位小数：" + scaledAmount); // 输出 12345.68

        // 2. 格式化输出（千分位、货币符号）
        DecimalFormat df = new DecimalFormat("###,###.00"); // 保留 2 位小数，千分位分隔
        String formatted = df.format(scaledAmount);
        System.out.println("格式化金额：" + formatted); // 输出 12,345.68

        // 3. 格式化货币（如人民币）
        DecimalFormat currencyDf = new DecimalFormat("¥###,###.00");
        System.out.println("货币格式：" + currencyDf.format(scaledAmount)); // 输出 ¥12,345.68
    }
}

2. 比较大小（避免使用 ==）

BigDecimal 是对象，== 比较的是内存地址，需使用 compareTo(BigDecimal val) 方法比较数值大小：

• 返回 0：两数相等；
• 返回 1：当前数大于参数；
• 返回 -1：当前数小于参数。

代码示例：比较大小

import java.math.BigDecimal;

public class BigDecimalCompareDemo {
    public static void main(String[] args) {
        BigDecimal x = new BigDecimal("10.00");
        BigDecimal y = new BigDecimal("10");
        BigDecimal z = new BigDecimal("10.01");

        System.out.println(x.equals(y));          // false（equals 比较值和标度，x 标度 2，y 标度 0）
        System.out.println(x.compareTo(y) == 0);  // true（compareTo 仅比较数值）
        System.out.println(x.compareTo(z) < 0);   // true（x < z）
        System.out.println(z.compareTo(x) > 0);   // true（z > x）
    }
}

3. 转换为基本类型

通过 xxxValue() 方法将 BigDecimal 转换为基本类型（需注意数值范围，避免溢出）：

BigDecimal num = new BigDecimal("123");
int intVal = num.intValue();      // 转换为 int
long longVal = num.longValue();   // 转换为 long
double doubleVal = num.doubleValue(); // 转换为 double（大数值可能丢失精度）

五、常见坑与注意事项

1. 避免使用 BigDecimal(double) 构造器

如前文所述，new BigDecimal(0.1) 会存储 0.1 的二进制近似值，导致精度丢失，必须使用字符串或 valueOf(double) 构造。

2. 除法必须指定舍入模式

当除法运算结果无法整除时（如 1.0 / 3），若未指定舍入模式，会抛出 ArithmeticException：

// 错误：未指定舍入模式，抛异常
// BigDecimal wrong = new BigDecimal("1.0").divide(new BigDecimal("3"));

// 正确：指定舍入模式
BigDecimal correct = new BigDecimal("1.0").divide(new BigDecimal("3"), RoundingMode.HALF_UP);

3. equals() 与 compareTo() 的区别

• equals()：比较数值 + 标度（如 10.00 和 10 不相等）；
• compareTo()：仅比较数值（如 10.00 和 10 相等）。

最佳实践：比较数值大小时用 compareTo()，判断是否完全相等（含标度）时用 equals()。

4. 不可变性导致的性能问题

BigDecimal 是不可变对象，每次运算都会创建新对象，频繁运算（如循环累加）会产生大量临时对象，影响性能。解决方案：

• 循环累加时使用可变类型（如 Guava 库提供的 MutableBigDecimal）；
• 非高频场景可忽略（BigDecimal 的精度优势优先于性能损耗）。

5. 空指针风险

BigDecimal 是引用类型，可能为 null，运算前需做非空判断：

// 推荐：非空判断（避免空指针异常）
public static BigDecimal add(BigDecimal a, BigDecimal b) {
    a = a == null ? BigDecimal.ZERO : a;
    b = b == null ? BigDecimal.ZERO : b;
    return a.add(b);
}

六、最佳实践总结

1. 创建对象：优先使用 BigDecimal(String) 或 BigDecimal.valueOf(double)，禁止使用 BigDecimal(double)；
2. 运算规则：除法必须指定舍入模式（推荐 RoundingMode.HALF_UP），复杂运算指定小数位数；
3. 比较大小：用 compareTo() 而非 == 或 equals()（除非需比较标度）；
4. 格式化输出：金额、数值展示时用 DecimalFormat 统一格式，避免直接 toString()；
5. 非空处理：方法参数或返回值为 BigDecimal 时，需做非空判断，默认值用 BigDecimal.ZERO；
6. 场景选择：金融计算、高精度场景强制使用 BigDecimal；普通场景（无精度要求）可使用 double 提升性能。

七、典型应用场景：金额计算

import java.math.BigDecimal;
import java.math.RoundingMode;

/**
 * 金额计算工具类（示例）
 */
public class MoneyUtils {
    // 小数位数（默认 2 位，对应分）
    private static final int SCALE = 2;
    // 舍入模式（四舍五入）
    private static final RoundingMode ROUND_MODE = RoundingMode.HALF_UP;

    // 加法
    public static BigDecimal add(BigDecimal a, BigDecimal b) {
        a = a == null ? BigDecimal.ZERO : a;
        b = b == null ? BigDecimal.ZERO : b;
        return a.add(b).setScale(SCALE, ROUND_MODE);
    }

    // 减法
    public static BigDecimal subtract(BigDecimal a, BigDecimal b) {
        a = a == null ? BigDecimal.ZERO : a;
        b = b == null ? BigDecimal.ZERO : b;
        return a.subtract(b).setScale(SCALE, ROUND_MODE);
    }

    // 乘法（如金额 × 税率）
    public static BigDecimal multiply(BigDecimal amount, BigDecimal rate) {
        amount = amount == null ? BigDecimal.ZERO : amount;
        rate = rate == null ? BigDecimal.ZERO : rate;
        return amount.multiply(rate).setScale(SCALE, ROUND_MODE);
    }

    // 除法（如金额 ÷ 数量）
    public static BigDecimal divide(BigDecimal amount, BigDecimal count) {
        amount = amount == null ? BigDecimal.ZERO : amount;
        count = count == null ? BigDecimal.ONE : count;
        return amount.divide(count, SCALE, ROUND_MODE);
    }

    public static void main(String[] args) {
        BigDecimal price = new BigDecimal("99.99"); // 单价
        BigDecimal count = new BigDecimal("3");     // 数量
        BigDecimal rate = new BigDecimal("0.06");   // 税率 6%

        BigDecimal total = multiply(price, count);       // 总价：99.99 × 3 = 299.97
        BigDecimal tax = multiply(total, rate);          // 税费：299.97 × 0.06 = 17.9982 → 18.00
        BigDecimal finalAmount = add(total, tax);        // 最终金额：299.97 + 18.00 = 317.97

        System.out.println("总价：" + total);             // 输出 299.97
        System.out.println("税费：" + tax);               // 输出 18.00
        System.out.println("最终金额：" + finalAmount);    // 输出 317.97
    }
}

通过 BigDecimal 可彻底解决浮点精度问题，尤其适用于对精度要求极高的场景。掌握其核心用法和最佳实践，能有效避免常见错误，确保计算结果的准确性。