BigDecimal实现加减乘除


一、BigDecimal构造方法(将其他类型转换成BigDecimal);

1、 public BigDecimal(char[] in) {
        this(in, 0, in.length);
    }

2、 public BigDecimal(String val) {
        this(val.toCharArray(), 0, val.length());
    }

3、 public BigDecimal(String val, MathContext mc) {
        this(val.toCharArray(), 0, val.length(), mc);
    }

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

5、 public BigDecimal(BigInteger val) {
        scale = 0;
        intVal = val;
        intCompact = compactValFor(val);
    }

6、 public BigDecimal(int val) {
        this.intCompact = val;
        this.scale = 0;
        this.intVal = null;
    }

7、 public BigDecimal(long val) {
        this.intCompact = val;
        this.intVal = (val == INFLATED) ? INFLATED_BIGINT : null;
        this.scale = 0;
    }

利用其构造方法客将不同类型的数字转换成BigDecimal类型的数字;

二、利用BigDecimal实现加法(加法的方法)

 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);
            }
        }
    }

三、利用BegDecimal实现减法(减法的方法)

  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);
            }
        }
    }

四、利用BigDecimal实现乘法(乘法方法)

 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);
            }
        }
    }

五、利用BigDecimal实现处罚(出发方法)

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

以上为BigDecimal单参实现加减乘除的源码-------------------

六、用例子实现加减乘除

  1. /**  
  2. * 提供精确的加法运算。  
  3. * @param v1 被加数  
  4. * @param v2 加数  
  5. * @return 两个参数的和  
  6. */  
  7. public static double add(double v1,double v2){   
  8. BigDecimal b1 = new BigDecimal(Double.toString(v1));   
  9. BigDecimal b2 = new BigDecimal(Double.toString(v2));   
  10. return b1.add(b2).doubleValue();   
  11. }   
  12. /**  
  13. * 提供精确的减法运算。  
  14. * @param v1 被减数  
  15. * @param v2 减数  
  16. * @return 两个参数的差  
  17. */  
  18. public static double sub(double v1,double v2){   
  19. BigDecimal b1 = new BigDecimal(Double.toString(v1));   
  20. BigDecimal b2 = new BigDecimal(Double.toString(v2));   
  21. return b1.subtract(b2).doubleValue();   
  22. }   
  23. /**  
  24. * 提供精确的乘法运算。  
  25. * @param v1 被乘数  
  26. * @param v2 乘数  
  27. * @return 两个参数的积  
  28. */  
  29. public static double mul(double v1,double v2){   
  30. BigDecimal b1 = new BigDecimal(Double.toString(v1));   
  31. BigDecimal b2 = new BigDecimal(Double.toString(v2));   
  32. return b1.multiply(b2).doubleValue();   
  33. }   
  34. /**  
  35. * 提供(相对)精确的除法运算,当发生除不尽的情况时,精确到  
  36. * 小数点以后10位,以后的数字四舍五入。  
  37. * @param v1 被除数  
  38. * @param v2 除数  
  39. * @return 两个参数的商  
  40. */  
  41. public static double div(double v1,double v2){   
  42. return div(v1,v2,DEF_DIV_SCALE);   
  43. }   
  44. /**  
  45. * 提供(相对)精确的除法运算。当发生除不尽的情况时,由scale参数指  
  46. * 定精度,以后的数字四舍五入。  
  47. * @param v1 被除数  
  48. * @param v2 除数  
  49. * @param scale 表示表示需要精确到小数点以后几位。  
  50. * @return 两个参数的商  
  51. */  
  52. public static double div(double v1,double v2,int scale){   
  53. if(scale<0){   
  54. throw new IllegalArgumentException(   
  55. "The scale must be a positive integer or zero");   
  56. }   
  57. BigDecimal b1 = new BigDecimal(Double.toString(v1));   
  58. BigDecimal b2 = new BigDecimal(Double.toString(v2));   
  59. return b1.divide(b2,scale,BigDecimal.ROUND_HALF_UP).doubleValue();   
  60. }  

 

 

***BigDecimal中的compareTo方法

BigDecimal a = new BigDecimal("1.00");
BigDecmial b = new BigDecimal(1);
想比较一下a和b的大小,一般都会用equals
System.out.println(a.equals(b));
但是输出结果是:false
原因是:BigDecimal比较时,不仅比较值,而且还比较精度?
if(a.compareTo(b)==0) 结果是true
比较大小可以用 a.compareTo(b)
返回值 -1 小于 0 等于 1 大于
智能推荐

注意!

本站转载的文章为个人学习借鉴使用,本站对版权不负任何法律责任。如果侵犯了您的隐私权益,请联系我们删除。



 
© 2014-2019 ITdaan.com 粤ICP备14056181号  

赞助商广告