大数值运算 详解

/** 飞翔科技 - 浮点数精度陷阱演示：为什么财务计算不能用float/double */
import java.math.BigDecimal;

public class FloatingPrecisionDemo {
    public static void main(String[] args) {
        System.out.println("========== 飞翔科技财务系统精度验证 ==========\n");

        // 经典案例：0.1 + 0.2
        double d1 = 0.1;
        double d2 = 0.2;
        double dSum = d1 + d2;
        System.out.println("【double 计算】0.1 + 0.2 = " + dSum);
        System.out.println("  预期：0.3");
        System.out.println("  实际：" + dSum + "  ← 出现了精度误差！");

        // 更真实的财务场景
        double price = 188.88;  // 飞翔科技产品单价
        double taxRate = 0.13;   // 增值税率 13%
        double taxDouble = price * taxRate;
        System.out.println("\n【double 税率计算】");
        System.out.println("  单价 " + price + " × 税率 " + taxRate + " = " + taxDouble);
        System.out.println("  期望精确值：24.5544  ← double可能产生微小误差");

        // BigDecimal的正确做法
        BigDecimal priceBD = new BigDecimal("188.88");
        BigDecimal taxRateBD = new BigDecimal("0.13");
        BigDecimal taxBD = priceBD.multiply(taxRateBD);
        System.out.println("\n【BigDecimal 税率计算】");
        System.out.println("  单价 " + priceBD + " × 税率 " + taxRateBD + " = " + taxBD);
        System.out.println("  >>> 精确无比！");

        // 贬低double构造器
        BigDecimal badBD = new BigDecimal(0.1);
        System.out.println("\n【BigDecimal(double) 陷阱】");
        System.out.println("  new BigDecimal(0.1) = " + badBD);
        System.out.println("  >>> 构造器继承了double的精度误差！");
        System.out.println("  >>> 正确写法：new BigDecimal(\"0.1\")");
    }
}

/** 飞翔科技 - 订单精确金额计算：含税、折扣、舍入 */
import java.math.BigDecimal;
import java.math.RoundingMode;

public class OrderCalculationDemo {
    public static void main(String[] args) {
        System.out.println("========== 飞翔科技订单结算 ==========\n");

        // 订单明细
        BigDecimal unitPrice    = new BigDecimal("188.88");    // 产品单价
        int           quantity  = 3;                           // 数量
        BigDecimal taxRate     = new BigDecimal("0.13");      // 增值税率 13%
        BigDecimal discountRate = new BigDecimal("0.15");     // 折扣率 15%

        // 1. 计算小计
        BigDecimal quantityBD = new BigDecimal(quantity);
        BigDecimal subtotal = unitPrice.multiply(quantityBD);
        System.out.println("【步骤1：小计】");
        System.out.println("  单价 " + unitPrice + " × 数量 " + quantity + " = " + subtotal);

        // 2. 计算税额（保留2位小数，HALF_UP四舍五入）
        BigDecimal tax = subtotal.multiply(taxRate)
                .setScale(2, RoundingMode.HALF_UP);
        System.out.println("\n【步骤2：税额】");
        System.out.println("  小计 " + subtotal + " × 税率 " + taxRate + " = " + subtotal.multiply(taxRate));
        System.out.println("  税额（保留2位，四舍五入）= " + tax);

        // 3. 计算含税总额
        BigDecimal totalWithTax = subtotal.add(tax);
        System.out.println("\n【步骤3：含税总额】");
        System.out.println("  小计 " + subtotal + " + 税额 " + tax + " = " + totalWithTax);

        // 4. 计算折扣
        BigDecimal discount = totalWithTax.multiply(discountRate)
                .setScale(2, RoundingMode.HALF_UP);
        System.out.println("\n【步骤4：折扣】");
        System.out.println("  含税总额 " + totalWithTax + " × 折扣率 " + discountRate + " = " + discount);

        // 5. 最终应付金额
        BigDecimal finalAmount = totalWithTax.subtract(discount);
        System.out.println("\n【步骤5：最终应付】");
        System.out.println("  含税总额 " + totalWithTax + " - 折扣 " + discount + " = " + finalAmount);

        // 6. 展示不同舍入模式
        BigDecimal value = new BigDecimal("188.885");
        System.out.println("\n【舍入模式对比】原始值：" + value);
        System.out.println("  HALF_UP（四舍五入）  → " + value.setScale(2, RoundingMode.HALF_UP));
        System.out.println("  HALF_DOWN（五舍六入） → " + value.setScale(2, RoundingMode.HALF_DOWN));
        System.out.println("  UP（向远离零方向）    → " + value.setScale(2, RoundingMode.UP));
        System.out.println("  DOWN（向零方向）      → " + value.setScale(2, RoundingMode.DOWN));
        System.out.println("  CEILING（天花板）     → " + value.setScale(2, RoundingMode.CEILING));
        System.out.println("  FLOOR（地板）         → " + value.setScale(2, RoundingMode.FLOOR));
    }
}

/** 飞翔科技 - 使用BigInteger计算大数阶乘（演示任意精度整数运算） */
import java.math.BigInteger;

public class BigFactorialDemo {
    public static void main(String[] args) {
        System.out.println("========== 飞翔科技 大数阶乘计算（BigInteger） ==========\n");

        // 计算 1! 到 50!，展示BigInteger的增长
        for (int n = 1; n <= 50; n++) {
            BigInteger factorial = factorial(n);
            if (n <= 10 || n % 10 == 0) {
                System.out.printf("  %2d! = %s%n", n, formatBigInteger(factorial));
            }
        }

        // 单独展示更大的阶乘
        System.out.println("\n--- 超大阶乘 ---");
        BigInteger fact100 = factorial(100);
        System.out.println("  100! = " + fact100);
        System.out.println("  位数：" + fact100.toString().length() + " 位");

        // BigInteger的位运算（RSA密钥相关）
        BigInteger twoPow256 = BigInteger.ONE.shiftLeft(256);  // 2^256
        System.out.println("\n【RSA密钥空间对比】");
        System.out.println("  2^256  = " + twoPow256);
        System.out.println("  位数：  " + twoPow256.toString().length() + " 位（十进制）");
        System.out.println("  >>> AES-256的密钥空间，远超宇宙中原子总数（~10^80）");
    }

    /** 飞翔科技 - 使用BigInteger计算阶乘 */
    public static BigInteger factorial(int n) {
        BigInteger result = BigInteger.ONE;
        for (int i = 2; i <= n; i++) {
            result = result.multiply(BigInteger.valueOf(i));
        }
        return result;
    }

    /** 飞翔科技 - 格式化大整数输出（超过40字符时截断显示） */
    public static String formatBigInteger(BigInteger bi) {
        String s = bi.toString();
        if (s.length() <= 40) return s;
        return s.substring(0, 20) + "..." + s.substring(s.length() - 17)
                + " (" + s.length() + " 位)";
    }
}

/** 飞翔科技 - 分期付款计算：处理除法除不尽与舍入 */
import java.math.BigDecimal;
import java.math.RoundingMode;

public class InstallmentDemo {
    public static void main(String[] args) {
        System.out.println("========== 飞翔科技分期付款计算 ==========\n");

        BigDecimal totalAmount = new BigDecimal("18888.88");  // 总金额
        int periods = 12;                                      // 12期

        System.out.println("分期总额：" + totalAmount);
        System.out.println("期数：" + periods + " 期");

        // 方案A：每期等额（HALF_UP）
        BigDecimal perPeriodA = totalAmount.divide(
                new BigDecimal(periods), 2, RoundingMode.HALF_UP);
        BigDecimal totalA = perPeriodA.multiply(new BigDecimal(periods));
        BigDecimal diffA = totalAmount.subtract(totalA);

        System.out.println("\n【方案A：HALF_UP 等额分期】");
        System.out.println("  每期金额：" + perPeriodA);
        System.out.println("  12期合计：" + totalA);
        System.out.println("  差额（银行吸收）：" + diffA);

        // 方案B：前11期等额，最后一期补差额
        BigDecimal perPeriodB = totalAmount.divide(
                new BigDecimal(periods), 2, RoundingMode.DOWN);
        BigDecimal total11 = perPeriodB.multiply(new BigDecimal(periods - 1));
        BigDecimal lastPeriod = totalAmount.subtract(total11);

        System.out.println("\n【方案B：前N-1期DOWN + 最后一期补差】");
        System.out.println("  前11期每期：" + perPeriodB);
        System.out.println("  最后1期：" + lastPeriod);
        System.out.println("  12期合计：" + total11.add(lastPeriod));

        // 方案C：展示除不尽的原始结果
        BigDecimal raw = totalAmount.divide(new BigDecimal(periods), 10, RoundingMode.HALF_UP);
        System.out.println("\n【原始除法结果（保留10位）】");
        System.out.println("  18888.88 ÷ 12 = " + raw);
        System.out.println("  无限循环小数：1574.07333...");
    }
}

BigDecimal a = new BigDecimal("100");
a.add(new BigDecimal("1"));    // ❌ 错误！返回值被丢弃，a仍然是100
a = a.add(new BigDecimal("1")); // ✅ 正确！必须赋值接收

// ❌ 致命错误！new BigDecimal(double) 继承了double的精度问题
BigDecimal bad1 = new BigDecimal(0.1);
System.out.println(bad1);
// 输出：0.1000000000000000055511151231257827021181583404541015625
// 这根本不是0.1！

BigDecimal bad2 = new BigDecimal(188.88);
// 同样存在不可预料的精度偏差

// ✅ 正确：始终使用字符串构造器
BigDecimal good1 = new BigDecimal("0.1");
System.out.println(good1);  // 输出：0.1  ← 精确！

// ✅ 或使用valueOf（内部也使用字符串转换，但有缓存）
BigDecimal good2 = BigDecimal.valueOf(188.88);  // 适用于double字面量
// 注意：BigDecimal.valueOf(0.1) 也能给出精确0.1

// ❌ 除不尽时抛 ArithmeticException
BigDecimal a = new BigDecimal("10");
BigDecimal b = new BigDecimal("3");
BigDecimal result = a.divide(b);  // ArithmeticException!
// Non-terminating decimal expansion; no exact representable decimal result.

// ✅ 正确：始终指定标度和舍入模式
BigDecimal result = a.divide(b, 2, RoundingMode.HALF_UP);  // 3.33

// ✅ 或使用MathContext
MathContext mc = new MathContext(4, RoundingMode.HALF_UP);
BigDecimal result2 = a.divide(b, mc);  // 3.333

// ❌ 标度不同导致equals不等，被视为不同元素
Set<BigDecimal> prices = new HashSet<>();
prices.add(new BigDecimal("2.0"));
prices.add(new BigDecimal("2.00"));
System.out.println(prices.size());  // 输出：2 ← 意料之外！
// equals比较：2.0(scale=1) ≠ 2.00(scale=2)

// ✅ 方案一：统一标度后再放入散列集合
Set<BigDecimal> prices = new HashSet<>();
prices.add(new BigDecimal("2.0").setScale(2));  // 2.00
prices.add(new BigDecimal("2.00").setScale(2)); // 2.00
System.out.println(prices.size());  // 输出：1 ← 正确

// ✅ 方案二：使用TreeSet（基于compareTo，忽略标度）
Set<BigDecimal> pricesTree = new TreeSet<>();
pricesTree.add(new BigDecimal("2.0"));
pricesTree.add(new BigDecimal("2.00"));
System.out.println(pricesTree.size());  // 输出：1 ← 正确

// ❌ 在TreeMap/TreeSet中看似没问题，但在业务逻辑中可能出错
BigDecimal price1 = new BigDecimal("188.88");
BigDecimal price2 = new BigDecimal("188.880");
if (price1.equals(price2)) {  // false！标度不同
    System.out.println("价格相等");
}

// ✅ 业务逻辑中判断数值相等：使用compareTo
if (price1.compareTo(price2) == 0) {  // true！数值相等
    System.out.println("价格相等");
}

// ✅ 最佳实践：创建时统一标度
BigDecimal price1 = new BigDecimal("188.88").setScale(2, RoundingMode.HALF_UP);
BigDecimal price2 = new BigDecimal("188.880").setScale(2, RoundingMode.HALF_UP);