关于BigDecimal操作,不会影响原对象的值

布满荆棘的人生 2022-01-26 01:37 322阅读 0赞

## 操作BigDecimal ##

BigDecimal bigDecimal1 = new BigDecimal("1");
            BigDecimal bigDecimal2 = new BigDecimal("2");
            bigDecimal1.multiply(bigDecimal2);
            bigDecimal1.add(bigDecimal2);
            bigDecimal1.subtract(bigDecimal2);
            bigDecimal1.divide(bigDecimal2);
    
            System.out.println(bigDecimal1);

输出

## 分析与源码 ##

查看BigDecimal源码

/**
         * If the absolute value of the significand of this BigDecimal is
         * less than or equal to {@code Long.MAX_VALUE}, the value can be
         * compactly stored in this field and used in computations.
         */
        private final transient long intCompact;
        /**
         * The scale of this BigDecimal, as returned by {@link #scale}.
         *
         * @serial
         * @see #scale
         */
        private final int scale;  // Note: this may have any value, so
                                  // calculations must be done in longs

可以发现,其实BigDecimal的实现就是一个long加上一个缩放等级, 对BigDecimal的操作都是对值进行操作,不会改变原来对象的值

add

/**
         * Returns a {@code BigDecimal} whose value is {@code (this +
         * augend)}, and whose scale is {@code max(this.scale(),
         * augend.scale())}.
         *
         * @param  augend value to be added to this {@code BigDecimal}.
         * @return {@code this + augend}
         */
        public BigDecimal add(BigDecimal augend) {
            if (this.intCompact != INFLATED) {
                if ((augend.intCompact != INFLATED)) {
                    return add(this.intCompact, this.scale, augend.intCompact, augend.scale);
                } else {
                    return add(this.intCompact, this.scale, augend.intVal, augend.scale);
                }
            } else {
                if ((augend.intCompact != INFLATED)) {
                    return add(augend.intCompact, augend.scale, this.intVal, this.scale);
                } else {
                    return add(this.intVal, this.scale, augend.intVal, augend.scale);
                }
            }
        }

subtract

/**
         * Returns a {@code BigDecimal} whose value is {@code (this -
         * subtrahend)}, and whose scale is {@code max(this.scale(),
         * subtrahend.scale())}.
         *
         * @param  subtrahend value to be subtracted from this {@code BigDecimal}.
         * @return {@code this - subtrahend}
         */
        public BigDecimal subtract(BigDecimal subtrahend) {
            if (this.intCompact != INFLATED) {
                if ((subtrahend.intCompact != INFLATED)) {
                    return add(this.intCompact, this.scale, -subtrahend.intCompact, subtrahend.scale);
                } else {
                    return add(this.intCompact, this.scale, subtrahend.intVal.negate(), subtrahend.scale);
                }
            } else {
                if ((subtrahend.intCompact != INFLATED)) {
                    // Pair of subtrahend values given before pair of
                    // values from this BigDecimal to avoid need for
                    // method overloading on the specialized add method
                    return add(-subtrahend.intCompact, subtrahend.scale, this.intVal, this.scale);
                } else {
                    return add(this.intVal, this.scale, subtrahend.intVal.negate(), subtrahend.scale);
                }
            }
        }

multiply

/**
         * Returns a {@code BigDecimal} whose value is <tt>(this ×
         * multiplicand)</tt>, and whose scale is {@code (this.scale() +
         * multiplicand.scale())}.
         *
         * @param  multiplicand value to be multiplied by this {@code BigDecimal}.
         * @return {@code this * multiplicand}
         */
        public BigDecimal multiply(BigDecimal multiplicand) {
            int productScale = checkScale((long) scale + multiplicand.scale);
            if (this.intCompact != INFLATED) {
                if ((multiplicand.intCompact != INFLATED)) {
                    return multiply(this.intCompact, multiplicand.intCompact, productScale);
                } else {
                    return multiply(this.intCompact, multiplicand.intVal, productScale);
                }
            } else {
                if ((multiplicand.intCompact != INFLATED)) {
                    return multiply(multiplicand.intCompact, this.intVal, productScale);
                } else {
                    return multiply(this.intVal, multiplicand.intVal, productScale);
                }
            }
        }

divide

/**
         * 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;
            }
        }