基于减法的自定义四舍五入算法出现浮点精度偏差问题

• 二进制浮点数固有精度缺陷：double类型遵循IEEE 754二进制浮点数标准，绝大多数十进制有限小数（例如0.001）无法被精确存储，初始化时就自带微小的取值误差。
• 循环运算累积误差：你的实现通过反复加减round_size的方式计算剩余尾数，每一次浮点加减运算都会放大已有的精度误差，多次循环后误差累积到可观测的程度，最终出现24.75500000000727这类不符合预期的结果。
• 额外性能缺陷：当前循环逻辑的时间复杂度为O(10^decimals)，当保留小数位数大于5时，循环次数会突破十万级，不仅运行效率极低，还可能因浮点误差出现死循环问题。

方案1：优化浮点实现逻辑（适用精度要求不高的场景） #

替换循环加减逻辑为放大取整逻辑，大幅减少运算次数，降低误差累积概率：

public class Round {
    public double round(double number, int decimals) {
        int scale = pow(10, decimals);
        // 正数四舍五入加0.5取整，负数减0.5取整
        if (number > 0) {
            return (long) (number * scale + 0.5) / (double) scale;
        } else if (number < 0) {
            return (long) (number * scale - 0.5) / (double) scale;
        }
        return 0;
    }
    
    private int pow(int base, int power) {
        int number = 1;
        for (int i = 0; i < power; i++) {
            number *= base;
        }
        return number;
    }
}

注意：该方案仍然使用double运算，仅能降低误差出现概率，无法完全避免二进制浮点精度问题。

方案2：基于BigDecimal的精确实现（适用精度要求高的场景） #

采用十进制运算类BigDecimal规避二进制浮点误差，自主实现四舍五入逻辑不依赖内置rounding函数：

public class Round {
    public double round(double number, int decimals) {
        String numStr = Double.toString(number);
        BigDecimal origin = new BigDecimal(numStr);
        BigDecimal scale = new BigDecimal(pow(10, decimals));
        // 放大指定倍数
        BigDecimal scaled = origin.multiply(scale);
        // 提取整数部分和小数部分做四舍五入判断
        BigDecimal integerPart = scaled.setScale(0, BigDecimal.ROUND_DOWN);
        BigDecimal fractionalPart = scaled.subtract(integerPart);
        
        BigDecimal roundedInt;
        if (origin.compareTo(BigDecimal.ZERO) > 0) {
            roundedInt = fractionalPart.compareTo(new BigDecimal("0.5")) >= 0 
                ? integerPart.add(BigDecimal.ONE) 
                : integerPart;
        } else {
            roundedInt = fractionalPart.compareTo(new BigDecimal("-0.5")) <= 0 
                ? integerPart.subtract(BigDecimal.ONE) 
                : integerPart;
        }
        // 缩小回原倍数返回
        return roundedInt.divide(scale).doubleValue();
    }
    
    private int pow(int base, int power) {
        int number = 1;
        for (int i = 0; i < power; i++) {
            number *= base;
        }
        return number;
    }
}

该方案完全基于十进制运算，可彻底解决精度偏差问题，测试输入round(24.754537, 3)可精确返回24.755。

内容的提问来源于stack exchange，提问作者xRodn