做金融、电商开发的朋友，大致率踩过 “小数计算不准” 的坑：明明是 0.1+0.2，结果却算出 0.30000000000000004；对账时差几分钱，查半天找不到缘由…… 实则问题根源很简单 —— 你用错了数据类型！
今天就把 “小数精准计算” 的底层逻辑和最佳实践讲透，尤其涉及钱、利率、百分比等场景，看完再也不用担心算错数。

一、为什么 double/float 算不准？不是 bug，是 “天生缺陷”

许多人以为 “0.1+0.2≠0.3” 是 Java 的 bug，实则这是浮点数的 “天生特性”——double 和 float 遵循 IEEE 754 二进制浮点数标准，有些十进制小数根本无法被准确表明。
就像我们用十进制无法准确表明 1/3（0.333... 无限循环），二进制也无法准确表明 0.1、0.2 这样的十进制小数。看个经典案例就懂了：

public class DoubleProblem {
  public static void main(String[] args) {
      double a = 0.1;
      double b = 0.2;
      double result = a + b;
      System.out.println(result); // 输出：0.30000000000000004
  }
}

你以为会得到 0.3，实际却是一串近似值。如果用这种结果算订单金额、利息，日积月累必然出问题 —— 列如电商满减计算差 1 分钱，金融利息少算几块钱，都是致命隐患。

二、精准计算的 “救星”：BigDecimal 怎么用才对？

Java 提供的java.math.BigDecimal，通过 “整数 + 非标度值” 的方式存储小数，能彻底解决精度问题。但许多人用不对，反而越用越乱，关键要记住 3 个核心要点：

1. 构造 BigDecimal：这 2 种方式正确，1 种绝对不能用！

绝对禁止用 double 构造 BigDecimal！会把 double 的误差直接带进来，等于白忙活：

// 错误！0.1的double本身就是近似值，构造后依然有误差
BigDecimal bad = new BigDecimal(0.1);
System.out.println(bad); // 输出：0.1000000000000000055511151231257827021181583404541015625
// 正确1：用String构造，完全保留十进制精度
BigDecimal good1 = new BigDecimal("0.1");
// 正确2：用BigDecimal.valueOf()，内部会转成String处理
BigDecimal good2 = BigDecimal.valueOf(0.1);
System.out.println(good1); // 输出：0.1
System.out.println(good2); // 输出：0.1

如果是整数（列如商品数量、订单 ID），用valueOf()更简洁；如果是小数（列如价格、利率），优先用String构造，确保万无一失。

2. 基本运算：加法减法简单，除法必须加 “舍入模式”

BigDecimal 的运算不能用+、-、*、/符号，要调用对应的方法。其中加法、减法、乘法直接用，除法必须指定 “舍入模式”，否则遇到无限小数会抛异常：

BigDecimal a = new BigDecimal("0.1");
BigDecimal b = new BigDecimal("0.2");
// 1. 加法：add()
BigDecimal sum = a.add(b);
System.out.println(sum); // 输出：0.3（精准！）
// 2. 减法：subtract()
BigDecimal difference = a.subtract(b);
System.out.println(difference); // 输出：-0.1
// 3. 乘法：multiply()
BigDecimal product = a.multiply(b);
System.out.println(product); // 输出：0.02
// 4. 除法：divide(除数, 保留小数位数, 舍入模式)
// 列如0.1/0.3，保留2位小数，四舍五入
BigDecimal quotient = a.divide(b, 2, RoundingMode.HALF_UP);
System.out.println(quotient); // 输出：0.50

常用舍入模式推荐：

• 金融计算（算钱）用RoundingMode.HALF_UP（四舍五入）；
• 避免超预算用RoundingMode.FLOOR（向下取整，列如算折扣只少不多）；
• 统计数量用RoundingMode.CEILING（向上取整，列如算需要多少个箱子）。

3. 比较大小：别用 equals ()，用 compareTo () 才对！

许多人习惯用equals()比较 BigDecimal，结果踩了 “标度坑”—— 列如 10.0 和 10.00，值一样但 “小数点后位数” 不同，equals()会判定为不相等：

BigDecimal num1 = new BigDecimal("10.0");  // 标度1（小数点后1位）
BigDecimal num2 = new BigDecimal("10.00"); // 标度2（小数点后2位）
System.out.println(num1.equals(num2)); // 输出：false（错！）
System.out.println(num1.compareTo(num2) == 0); // 输出：true（对！）

compareTo()返回 int 值：

• 返回 0：两个数相等；
• 返回正数：前者大于后者；
• 返回负数：前者小于后者。
  实际开发中，比较金额是否达标、利率是否超过阈值，都要用compareTo()。

三、实战案例：电商订单计算，完整精准流程

结合电商 “商品总价 - 折扣 = 实付金额” 的场景，看一套完整的最佳实践：

import java.math.BigDecimal;
import java.math.RoundingMode;
public class OrderCalculation {
  public static void main(String[] args) {
      // 1. 正确创建参数：价格、数量、折扣（用String或valueOf）
      BigDecimal price = new BigDecimal("19.99");    // 单价19.99元
      BigDecimal quantity = BigDecimal.valueOf(3);   // 购买3件
      BigDecimal discountRate = new BigDecimal("0.1");// 10%折扣
      // 2. 分步计算：先算总价，再算折扣，最后算实付
      BigDecimal totalPrice = price.multiply(quantity); // 总价：19.99*3=59.97
      BigDecimal discountAmount = totalPrice.multiply(discountRate); // 折扣：59.97*0.1=5.997
      // 实付金额：保留2位小数，四舍五入（59.97-5.997=53.973→53.97）
      BigDecimal finalPrice = totalPrice.subtract(discountAmount)
                                        .setScale(2, RoundingMode.HALF_UP);
      // 3. 输出结果（精准无误差）
      System.out.println("商品总价：￥" + totalPrice);      // 商品总价：￥59.97
      System.out.println("折扣金额：￥" + discountAmount); // 折扣金额：￥5.997
      System.out.println("实付金额：￥" + finalPrice);     // 实付金额：￥53.97
      // 4. 比较：判断是否满足满50减5的条件
      BigDecimal minForDiscount = new BigDecimal("50.00");
      if (finalPrice.compareTo(minForDiscount) >= 0) {
          System.out.println("满足满50减5，可再减5元！");
      }
  }
}

运行结果完全符合预期，没有任何精度误差 —— 这就是金融、电商场景必须用 BigDecimal 的缘由。

四、最后总结：5 条黄金法则，记牢不踩坑

1. 构造必用 String/valueOf：绝对不用 double 构造，避免误差带入；
2. 除法必加舍入模式：不管是否整除，都指定保留位数和舍入方式，防止抛异常；
3. 比较只用 compareTo：equals () 会比标度，compareTo () 才比实际值；
4. 记住不可变性：BigDecimal 每次运算都会返回新对象，别直接用原对象接收（列如a = a.add(b)）；
5. 性能权衡要清楚：BigDecimal 比 double 慢，但精准计算场景（钱、利率）必须用，这是必要代价。
   最后再强调一次：只要涉及 “需要准确到分、厘” 的计算，别犹豫，直接用 BigDecimal！哪怕多写几行代码，也比后期查账、改 bug 省事。你之前踩过小数计算的坑吗？评论区聊聊你的经历～