关于使用BigDecimal对象的除法“public BigDecimal divide(BigDecimal divisor)”报异常错误ArithmeticException

秒速五厘米 2021-10-09 08:40 607阅读 0赞

具体错误如下：![20200511162010286.png][]

/**
         * Returns a {@code BigDecimal} whose value is {@code (this /
         * divisor)}, and whose preferred scale is {@code (this.scale() -
         * divisor.scale())}; if the exact quotient cannot be
         * represented (because it has a non-terminating decimal
         * expansion) an {@code ArithmeticException} is thrown.
         *
         * @param  divisor value by which this {@code BigDecimal} is to be divided.
         * @throws ArithmeticException if the exact quotient does not have a
         *         terminating decimal expansion
         * @return {@code this / divisor}
         * @since 1.5
         * @author Joseph D. Darcy
         */
        public BigDecimal divide(BigDecimal divisor) {
            /*
             * Handle zero cases first.
             */
            if (divisor.signum() == 0) {   // x/0
                if (this.signum() == 0)    // 0/0
                    throw new ArithmeticException("Division undefined");  // NaN
                throw new ArithmeticException("Division by zero");
            }
    
            // Calculate preferred scale
            int preferredScale = saturateLong((long) this.scale - divisor.scale);
    
            if (this.signum() == 0) // 0/y
                return zeroValueOf(preferredScale);
            else {
                /*
                 * If the quotient this/divisor has a terminating decimal
                 * expansion, the expansion can have no more than
                 * (a.precision() + ceil(10*b.precision)/3) digits.
                 * Therefore, create a MathContext object with this
                 * precision and do a divide with the UNNECESSARY rounding
                 * mode.
                 */
                MathContext mc = new MathContext( (int)Math.min(this.precision() +
                                                                (long)Math.ceil(10.0*divisor.precision()/3.0),
                                                                Integer.MAX_VALUE),
                                                  RoundingMode.UNNECESSARY);
                BigDecimal quotient;
                try {
                    quotient = this.divide(divisor, mc);
                } catch (ArithmeticException e) {
                    throw new ArithmeticException("Non-terminating decimal expansion; " +
                                                  "no exact representable decimal result.");
                }
    
                int quotientScale = quotient.scale();
    
                // divide(BigDecimal, mc) tries to adjust the quotient to
                // the desired one by removing trailing zeros; since the
                // exact divide method does not have an explicit digit
                // limit, we can add zeros too.
                if (preferredScale > quotientScale)
                    return quotient.setScale(preferredScale, ROUND_UNNECESSARY);
    
                return quotient;
            }
        }

通过看源码可以知道，

* @throws ArithmeticException if the exact quotient does not have a
    *         terminating decimal expansion

他计算出的结果如果没有确切的整数，则抛异常，比如1/3，会一直0.333333333333333333....那么这种计算式子就会抛异常，所以我们需要设置精确位数

使用方法“public BigDecimal divide(BigDecimal divisor, int scale, int roundingMode)”就可以了

![20200511162351381.png][]

/**
         * Returns a {@code BigDecimal} whose value is {@code (this /
         * divisor)}, and whose scale is as specified.  If rounding must
         * be performed to generate a result with the specified scale, the
         * specified rounding mode is applied.
         *
         * <p>The new {@link #divide(BigDecimal, int, RoundingMode)} method
         * should be used in preference to this legacy method.
         *
         * @param  divisor value by which this {@code BigDecimal} is to be divided.
         * @param  scale scale of the {@code BigDecimal} quotient to be returned.
         * @param  roundingMode rounding mode to apply.
         * @return {@code this / divisor}
         * @throws ArithmeticException if {@code divisor} is zero,
         *         {@code roundingMode==ROUND_UNNECESSARY} and
         *         the specified scale is insufficient to represent the result
         *         of the division exactly.
         * @throws IllegalArgumentException if {@code roundingMode} does not
         *         represent a valid rounding mode.
         * @see    #ROUND_UP
         * @see    #ROUND_DOWN
         * @see    #ROUND_CEILING
         * @see    #ROUND_FLOOR
         * @see    #ROUND_HALF_UP
         * @see    #ROUND_HALF_DOWN
         * @see    #ROUND_HALF_EVEN
         * @see    #ROUND_UNNECESSARY
         */
        public BigDecimal divide(BigDecimal divisor, int scale, int roundingMode) {
            if (roundingMode < ROUND_UP || roundingMode > ROUND_UNNECESSARY)
                throw new IllegalArgumentException("Invalid rounding mode");
            if (this.intCompact != INFLATED) {
                if ((divisor.intCompact != INFLATED)) {
                    return divide(this.intCompact, this.scale, divisor.intCompact, divisor.scale, scale, roundingMode);
                } else {
                    return divide(this.intCompact, this.scale, divisor.intVal, divisor.scale, scale, roundingMode);
                }
            } else {
                if ((divisor.intCompact != INFLATED)) {
                    return divide(this.intVal, this.scale, divisor.intCompact, divisor.scale, scale, roundingMode);
                } else {
                    return divide(this.intVal, this.scale, divisor.intVal, divisor.scale, scale, roundingMode);
                }
            }
        }

[20200511162010286.png]: /images/20211009/fffa725290e2453788900e5c7da6caa0.png
[20200511162351381.png]: /images/20211009/a8a0bbbb454e4bda91dcf21b1ff9d184.png