简谈：java种关于BigDecimal的坑

╰+攻爆jí腚メ 2021-12-17 16:35 450阅读 0赞

最近踩了一个坑，关于使用BigDecimal时所产生的问题。

我们知道在我们进行一些货币计算的时候，一般采用BigDecimal的方法来进行运算。而不是通过double和long浮点型进行运算。就是因为Java种double或者long采用的是二进制浮点运算。而二进制不能充分准确的表示出浮点数的。举个例子，当我们用十进制时无法准确的表示1/3一样。只能通过0.3333...无限循环的方式来表示，当我们要求只保持几位小数时就会导致精度丢失。这就导致在进行货币这种对运算要求精度极高的场景时，就不能采取二进制浮点计算。

而BigDecimal正好可以解决这个问题。

本篇文章不对BigDecimal的运算进行分析，只是谈下我们在运算之初，创建BigDecimal对象时可能产生的问题。

jdk1.8版本种提供了16个创建对象的构造方法，而我们最常用的为以下两种：

public BigDecimal(double val) {
            this(val,MathContext.UNLIMITED);
        }
    
        public BigDecimal(String val) {
            this(val.toCharArray(), 0, val.length());
        }

首先，先写个test，看着两个方法有什么区别：

@Test
        public void testBigDecimal() {
           BigDecimal strStru = new BigDecimal("111.145");
           BigDecimal strDoub = new BigDecimal(111.145);
           System.out.println(strStru.setScale(2,BigDecimal.ROUND_HALF_UP));
           System.out.println(strDoub.setScale(2,BigDecimal.ROUND_HALF_UP));
        }

执行结果：

111.15
    111.14

可以看到，public BigDecimal(double val)\{...\}这个构造器没有得到我们正常四舍五入的值：111.15

debug下看看:

![20190708204135542.png][]

可以看到在进行初始化时构造方法public BigDecimal(double val)\{...\}由111.145变成111.1449999999999960209606797434389591217041015625从而导致在进行四舍五入时导致数据不准确

源码一分析：

public BigDecimal(String val) {
            this(val.toCharArray(), 0, val.length());
        }
    
        public BigDecimal(char[] in, int offset, int len) {
            this(in,offset,len,MathContext.UNLIMITED);
        }
    
       
    
        public BigDecimal(char[] in, int offset, int len, MathContext mc) {
            // protect against huge length.
            if (offset + len > in.length || offset < 0)
                throw new NumberFormatException("Bad offset or len arguments for char[] input.");
            // This is the primary string to BigDecimal constructor; all
            // incoming strings end up here; it uses explicit (inline)
            // parsing for speed and generates at most one intermediate
            // (temporary) object (a char[] array) for non-compact case.
    
            // Use locals for all fields values until completion
            int prec = 0;                 // record precision value
            int scl = 0;                  // record scale value
            long rs = 0;                  // the compact value in long
            BigInteger rb = null;         // the inflated value in BigInteger
            // use array bounds checking to handle too-long, len == 0,
            // bad offset, etc.
            try {
                // handle the sign
                boolean isneg = false;          // assume positive
                if (in[offset] == '-') {
                    isneg = true;               // leading minus means negative
                    offset++;
                    len--;
                } else if (in[offset] == '+') { // leading + allowed
                    offset++;
                    len--;
                }
    
                // should now be at numeric part of the significand
                boolean dot = false;             // true when there is a '.'
                long exp = 0;                    // exponent
                char c;                          // current character
                boolean isCompact = (len <= MAX_COMPACT_DIGITS);
                // integer significand array & idx is the index to it. The array
                // is ONLY used when we can't use a compact representation.
                int idx = 0;
                if (isCompact) {
                    // First compact case, we need not to preserve the character
                    // and we can just compute the value in place.
                    for (; len > 0; offset++, len--) {
                        c = in[offset];
                        if ((c == '0')) { // have zero
                            if (prec == 0)
                                prec = 1;
                            else if (rs != 0) {
                                rs *= 10;
                                ++prec;
                            } // else digit is a redundant leading zero
                            if (dot)
                                ++scl;
                        } else if ((c >= '1' && c <= '9')) { // have digit
                            int digit = c - '0';
                            if (prec != 1 || rs != 0)
                                ++prec; // prec unchanged if preceded by 0s
                            rs = rs * 10 + digit;
                            if (dot)
                                ++scl;
                        } else if (c == '.') {   // have dot
                            // have dot
                            if (dot) // two dots
                                throw new NumberFormatException();
                            dot = true;
                        } else if (Character.isDigit(c)) { // slow path
                            int digit = Character.digit(c, 10);
                            if (digit == 0) {
                                if (prec == 0)
                                    prec = 1;
                                else if (rs != 0) {
                                    rs *= 10;
                                    ++prec;
                                } // else digit is a redundant leading zero
                            } else {
                                if (prec != 1 || rs != 0)
                                    ++prec; // prec unchanged if preceded by 0s
                                rs = rs * 10 + digit;
                            }
                            if (dot)
                                ++scl;
                        } else if ((c == 'e') || (c == 'E')) {
                            exp = parseExp(in, offset, len);
                            // Next test is required for backwards compatibility
                            if ((int) exp != exp) // overflow
                                throw new NumberFormatException();
                            break; // [saves a test]
                        } else {
                            throw new NumberFormatException();
                        }
                    }
                    if (prec == 0) // no digits found
                        throw new NumberFormatException();
                    // Adjust scale if exp is not zero.
                    if (exp != 0) { // had significant exponent
                        scl = adjustScale(scl, exp);
                    }
                    rs = isneg ? -rs : rs;
                    int mcp = mc.precision;
                    int drop = prec - mcp; // prec has range [1, MAX_INT], mcp has range [0, MAX_INT];
                                           // therefore, this subtract cannot overflow
                    if (mcp > 0 && drop > 0) {  // do rounding
                        while (drop > 0) {
                            scl = checkScaleNonZero((long) scl - drop);
                            rs = divideAndRound(rs, LONG_TEN_POWERS_TABLE[drop], mc.roundingMode.oldMode);
                            prec = longDigitLength(rs);
                            drop = prec - mcp;
                        }
                    }
                } else {
                    char coeff[] = new char[len];
                    for (; len > 0; offset++, len--) {
                        c = in[offset];
                        // have digit
                        if ((c >= '0' && c <= '9') || Character.isDigit(c)) {
                            // First compact case, we need not to preserve the character
                            // and we can just compute the value in place.
                            if (c == '0' || Character.digit(c, 10) == 0) {
                                if (prec == 0) {
                                    coeff[idx] = c;
                                    prec = 1;
                                } else if (idx != 0) {
                                    coeff[idx++] = c;
                                    ++prec;
                                } // else c must be a redundant leading zero
                            } else {
                                if (prec != 1 || idx != 0)
                                    ++prec; // prec unchanged if preceded by 0s
                                coeff[idx++] = c;
                            }
                            if (dot)
                                ++scl;
                            continue;
                        }
                        // have dot
                        if (c == '.') {
                            // have dot
                            if (dot) // two dots
                                throw new NumberFormatException();
                            dot = true;
                            continue;
                        }
                        // exponent expected
                        if ((c != 'e') && (c != 'E'))
                            throw new NumberFormatException();
                        exp = parseExp(in, offset, len);
                        // Next test is required for backwards compatibility
                        if ((int) exp != exp) // overflow
                            throw new NumberFormatException();
                        break; // [saves a test]
                    }
                    // here when no characters left
                    if (prec == 0) // no digits found
                        throw new NumberFormatException();
                    // Adjust scale if exp is not zero.
                    if (exp != 0) { // had significant exponent
                        scl = adjustScale(scl, exp);
                    }
                    // Remove leading zeros from precision (digits count)
                    rb = new BigInteger(coeff, isneg ? -1 : 1, prec);
                    rs = compactValFor(rb);
                    int mcp = mc.precision;
                    if (mcp > 0 && (prec > mcp)) {
                        if (rs == INFLATED) {
                            int drop = prec - mcp;
                            while (drop > 0) {
                                scl = checkScaleNonZero((long) scl - drop);
                                rb = divideAndRoundByTenPow(rb, drop, mc.roundingMode.oldMode);
                                rs = compactValFor(rb);
                                if (rs != INFLATED) {
                                    prec = longDigitLength(rs);
                                    break;
                                }
                                prec = bigDigitLength(rb);
                                drop = prec - mcp;
                            }
                        }
                        if (rs != INFLATED) {
                            int drop = prec - mcp;
                            while (drop > 0) {
                                scl = checkScaleNonZero((long) scl - drop);
                                rs = divideAndRound(rs, LONG_TEN_POWERS_TABLE[drop], mc.roundingMode.oldMode);
                                prec = longDigitLength(rs);
                                drop = prec - mcp;
                            }
                            rb = null;
                        }
                    }
                }
            } catch (ArrayIndexOutOfBoundsException e) {
                throw new NumberFormatException();
            } catch (NegativeArraySizeException e) {
                throw new NumberFormatException();
            }
            this.scale = scl;
            this.precision = prec;
            this.intCompact = rs;
            this.intVal = rb;
        }

可以看出以字符串的方式构造BigDecimal对象时，里面进行了类似于十进制的方式进行初始化。

源码二分析

/** The results of this constructor can be somewhat unpredictable.
         * One might assume that writing {@code new BigDecimal(0.1)} in
         * Java creates a {@code BigDecimal} which is exactly equal to
         * 0.1 (an unscaled value of 1, with a scale of 1), but it is
         * actually equal to
         * 0.1000000000000000055511151231257827021181583404541015625.
         * This is because 0.1 cannot be represented exactly as a
         * {@code double} (or, for that matter, as a binary fraction of
         * any finite length).  Thus, the value that is being passed
         * <i>in</i> to the constructor is not exactly equal to 0.1,
         * appearances notwithstanding.
         */
        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;
        }

[20190708204135542.png]: /images/20211213/a427711328834afb9d84e7b7b1dcd942.png