JDK8 BigDecimal API-创建BigDecimal源码浅析三

第三篇

先介绍以BigInteger为构造参数的构造器

     public BigDecimal(BigInteger val) {// 根据BigInteger创建BigDecimal对象
         scale = 0;// BigInteger为整数因此有效小数位数为0
         intVal = val;
         intCompact = compactValFor(val);
     }

     public BigDecimal(BigInteger unscaledVal, int scale) {// 这个与上一个差不多但是指定了有效小数位数,但是最终的BigDecimal的数值为unscaledVal*10^-scale次方
         // Negative scales are now allowed
         this.intVal = unscaledVal;
         this.intCompact = compactValFor(unscaledVal);
         this.scale = scale;
     }

     public BigDecimal(BigInteger val, MathContext mc) {// 该方法转发调用下面的构造器
         this(val,0,mc);
     }

     public BigDecimal(BigInteger unscaledVal, int scale, MathContext mc) {
         long compactVal = compactValFor(unscaledVal);
         int mcp = mc.precision;
         int prec = 0;
         if (mcp > 0) { // do rounding,根据MathContext中的有效位数进行舍去操作,具体解析见第一篇BigDecimal源码解析文章
             int mode = mc.roundingMode.oldMode;
             if (compactVal == INFLATED) {
                 prec = bigDigitLength(unscaledVal);
                 int drop = prec - mcp;
                 while (drop > 0) {
                     scale = checkScaleNonZero((long) scale - drop);
                     unscaledVal = divideAndRoundByTenPow(unscaledVal, drop, mode);
                     compactVal = compactValFor(unscaledVal);
                     if (compactVal != INFLATED) {
                         break;
                     }
                     prec = bigDigitLength(unscaledVal);
                     drop = prec - mcp;
                 }
             }
             if (compactVal != INFLATED) {
                 prec = longDigitLength(compactVal);
                 int drop = prec - mcp;     // drop can't be more than 18
                 while (drop > 0) {
                     scale = checkScaleNonZero((long) scale - drop);
                     compactVal = divideAndRound(compactVal, LONG_TEN_POWERS_TABLE[drop], mode);
                     prec = longDigitLength(compactVal);
                     drop = prec - mcp;
                 }
                 unscaledVal = null;
             }
         }
         this.intVal = unscaledVal;
         this.intCompact = compactVal;
         this.scale = scale;
         this.precision = prec;// 若MathContext中的有效位数小于等于0,则BigDecimal中的有效位数置为0
     }

接下来介绍以int类型为构造参数的构造器

     public BigDecimal(int val) {// 以int数值来创建BigDecimal对象,int类型为整数则有效小数位数为0
         this.intCompact = val;
         this.scale = 0;
         this.intVal = null;// 此时BigDecimal的数值在int类型的表数范围因此也在long类型的表数范围,所以intVal为null
     }

     public BigDecimal(int val, MathContext mc) {// 该构造器在以int类型为参数的同时传入一个MathContext来限制有效位数
         int mcp = mc.precision;
         long compactVal = val;
         int scale = 0;
         int prec = 0;
         if (mcp > 0) { // do rounding,根据val的位数与MathContext的有效位数修正最终值的有效位数,即进行舍去操作,具体分析见第一篇BigDecimal源码分析文章
             prec = longDigitLength(compactVal);
             int drop = prec - mcp; // drop can't be more than 18
             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;
             }
         }
         this.intVal = null;
         this.intCompact = compactVal;// BigDecimal对象表示数值的简洁值就是int类型参数val
         this.scale = scale;
         this.precision = prec;
     }

long类型参数的构造器分析

     public BigDecimal(long val) {// 以long类型数值来创建BigDecimal对象,long类型为整数则有效小数位数为0
         this.intCompact = val;
         this.intVal = (val == INFLATED) ? INFLATED_BIGINT : null;// 若val的数值为long类型最小值需要特殊处理,因为此时的val有特殊含义(数值在long类型下溢出)
         this.scale = 0;
     }

     public BigDecimal(long val, MathContext mc) {// 该构造器在以long类型为参数的同时传入一个MathContext来限制有效位数
         int mcp = mc.precision;
         int mode = mc.roundingMode.oldMode;
         int prec = 0;
         int scale = 0;
         BigInteger intVal = (val == INFLATED) ? INFLATED_BIGINT : null;
         if (mcp > 0) { // do rounding,根据val的位数与MathContext的有效位数修正最终值的有效位数,即进行舍去操作,具体分析见第一篇BigDecimal源码分析文章
             if (val == INFLATED) {// 若val为INFLATED即-2^63,该数位数为19,因此初始化有效位数为19
                 prec = 19;
                 int drop = prec - mcp;
                 while (drop > 0) {
                     scale = checkScaleNonZero((long) scale - drop);
                     intVal = divideAndRoundByTenPow(intVal, drop, mode);
                     val = compactValFor(intVal);
                     if (val != INFLATED) {
                         break;
                     }
                     prec = bigDigitLength(intVal);
                     drop = prec - mcp;
                 }
             }
             if (val != INFLATED) {
                 prec = longDigitLength(val);
                 int drop = prec - mcp;
                 while (drop > 0) {
                     scale = checkScaleNonZero((long) scale - drop);
                     val = divideAndRound(val, LONG_TEN_POWERS_TABLE[drop], mc.roundingMode.oldMode);
                     prec = longDigitLength(val);
                     drop = prec - mcp;
                 }
                 intVal = null;
             }
         }
         this.intVal = intVal;
         this.intCompact = val;
         this.scale = scale;
         this.precision = prec;
     }

BigDecimal的原码接下来是一堆的静态方法用于创建BigDecimal对象,几乎没有什么需要分析的,很简单大家可以自己看一看