BigDecimal丢失精度的坑

最新推荐文章于 2024-09-12 13:56:40 发布

茅坤宝骏氹

最新推荐文章于 2024-09-12 13:56:40 发布

阅读量4k

点赞数 1

分类专栏： java 基本类型与包装类

本文链接：https://blog.csdn.net/moakun/article/details/83313001

版权

java 基本类型与包装类专栏收录该内容

13 篇文章

订阅专栏

探讨了使用BigDecimal(double)构造方法导致数值精度丢失的原因，详细解释了BigDecimal如何将double转换为longbits并进行移位计算，指出此过程无法精确表示某些double值。建议将double转换为String后再使用BigDecimal(String)构造方法，以避免精度损失。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

问题：new BigDecimal(double d)的数值居然还是不精确的

double d = 0.09;
BigDecimal bigDecimal=new BigDecimal(d);
System.out.println(bigDecimal);
System.out.println(d);

输出结果：

0.0899999999999999966693309261245303787291049957275390625

0.09

原因：BigDecimal将double数据转换成为long bits，进行移位计算数值，而double的long bits移位计算是无法得到0.09的精确数值，所有造成数据精度丢失。

为了避免丢失double的数据精度，将double数据转成String，使用BigDecimal(String s)构造方法。

public class  BigDecimal extends Number implements Comparable<BigDecimal>{

   public BigDecimal(double val) {
        this(val,MathContext.UNLIMITED);
   }

   public BigDecimal(double val, MathContext mc) {
        if (Double.isInfinite(val) || Double.isNaN(val))
            throw new NumberFormatException("Infinite or NaN");
        // Translate the double into sign, exponent and significand, according
        // to the formulae in JLS, Section 20.10.22.
        long valBits = Double.doubleToLongBits(val);
        int sign = ((valBits >> 63) == 0 ? 1 : -1);
        int exponent = (int) ((valBits >> 52) & 0x7ffL);
        long significand = (exponent == 0
                ? (valBits & ((1L << 52) - 1)) << 1
                : (valBits & ((1L << 52) - 1)) | (1L << 52));
        exponent -= 1075;
        // At this point, val == sign * significand * 2**exponent.

        /*
         * Special case zero to supress nonterminating normalization and bogus
         * scale calculation.
         */
        if (significand == 0) {
            this.intVal = BigInteger.ZERO;
            this.scale = 0;
            this.intCompact = 0;
            this.precision = 1;
            return;
        }
        // Normalize
        while ((significand & 1) == 0) { // i.e., significand is even
            significand >>= 1;
            exponent++;
        }
        int scale = 0;
        // Calculate intVal and scale
        BigInteger intVal;
        long compactVal = sign * significand;
        if (exponent == 0) {
            intVal = (compactVal == INFLATED) ? INFLATED_BIGINT : null;
        } else {
            if (exponent < 0) {
                intVal = BigInteger.valueOf(5).pow(-exponent).multiply(compactVal);
                scale = -exponent;
            } else { //  (exponent > 0)
                intVal = BigInteger.valueOf(2).pow(exponent).multiply(compactVal);
            }
            compactVal = compactValFor(intVal);
        }
        int prec = 0;
        int mcp = mc.precision;
        if (mcp > 0) { // do rounding
            int mode = mc.roundingMode.oldMode;
            int drop;
            if (compactVal == INFLATED) {
                prec = bigDigitLength(intVal);
                drop = prec - mcp;
                while (drop > 0) {
                    scale = checkScaleNonZero((long) scale - drop);
                    intVal = divideAndRoundByTenPow(intVal, drop, mode);
                    compactVal = compactValFor(intVal);
                    if (compactVal != INFLATED) {
                        break;
                    }
                    prec = bigDigitLength(intVal);
                    drop = prec - mcp;
                }
            }
            if (compactVal != INFLATED) {
                prec = longDigitLength(compactVal);
                drop = prec - mcp;
                while (drop > 0) {
                    scale = checkScaleNonZero((long) scale - drop);
                    compactVal = divideAndRound(compactVal, LONG_TEN_POWERS_TABLE[drop], mc.roundingMode.oldMode);
                    prec = longDigitLength(compactVal);
                    drop = prec - mcp;
                }
                intVal = null;
            }
        }
        this.intVal = intVal;
        this.intCompact = compactVal;
        this.scale = scale;
        this.precision = prec;
    }
}