一文带你读懂 BigDecimal 源码

ONE值1，标度为0。

  /**
   * <p>加法</p> 
   */
  private static BigDecimal add(final long xs, int scale1, final long ys, int scale2) {
    // 1 比较两者的标量
    long sdiff = (long) scale1 - scale2;
    if (sdiff == 0) {
      // 2 标量一样可以直接相加运算
      return add(xs, ys, scale1);
    } else if (sdiff < 0) {
      // 3 加数的标量 < 被加数的标量 ,获取标量差异的绝对值(eg：0.1 + 0.01，那么此时的 sdiff 就是 1)
      int raise = checkScale(xs,-sdiff);
      // 将加数乘以10^n次方，因为其scale标量会设置为跟被加数的scale标量相同
      long scaledX = longMultiplyPowerTen(xs, raise);
      // 加数扩大之后的结果没有溢出（超过Long类型支持的最大值）
      if (scaledX != INFLATED) {
        // 相同标量的两者进行相加操作，并返回操作结果（注意返回值是new了一个对象进行存储！！）
        return add(scaledX, ys, scale2);
      } else {
        BigInteger bigsum = bigMultiplyPowerTen(xs,raise).add(ys);
        return ((xs^ys)>=0) ? // same sign test
            new BigDecimal(bigsum, INFLATED, scale2, 0)
            : valueOf(bigsum, scale2, 0);
      }
    } else {
      // 4 加数的标量 > 被加数的标量 ,获取标量差异的绝对值(eg：0.01 + 0.1，那么此时的 sdiff 就是 -1)
      int raise = checkScale(ys,sdiff);
      // 将被加数乘以10^n次方，（n此时为负数），因为其scale标量会设置为跟加数的scale标量相同
      long scaledY = longMultiplyPowerTen(ys, raise);
      // 被加数扩大之后的结果没有溢出（超过Long类型支持的最大值）
      if (scaledY != INFLATED) {
        // 相同标量的两者进行相加操作，并返回操作结果（注意返回值是new了一个对象进行存储！！）
        return add(xs, scaledY, scale1);
      } else {
        BigInteger bigsum = bigMultiplyPowerTen(ys,raise).add(xs);
        return ((xs^ys)>=0) ?
            new BigDecimal(bigsum, INFLATED, scale1, 0)
            : valueOf(bigsum, scale1, 0);
      }
    }
  }

  /**
   * <p>减法，注意运算结果也是封装在新的对象里，千万注意返回值！！</p>
   */
  public BigDecimal subtract(BigDecimal subtrahend, MathContext mc) {
    // MathContext 的 precision 属性：用于定义操作的位数;，即结果四舍五入到这个精度
    if (mc.precision == 0)
      // 精度等于0，表示可以直接运算得出结果
      return subtract(subtrahend);
    // 如果需要四舍五入
    return add(subtrahend.negate(), mc);
  }

  public BigDecimal subtract(BigDecimal subtrahend) {
    // 减法的本质就是与一个值相反的数进行相加
    if (this.intCompact != INFLATED) {
      if ((subtrahend.intCompact != INFLATED)) {
        // 取相反值进行加法操作，这里的加法操作跟上文对add的源码解读完全一致！！
        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);
      }
    }
  }

  public BigDecimal add(BigDecimal augend, MathContext mc) {
    // 精度等于0，表示可以直接运算得出结果
    if (mc.precision == 0)
      return add(augend);
    BigDecimal lhs = this;

    // If either number is zero then the other number, rounded and
    // scaled if necessary, is used as the result.
    {
      // 精度是否为0
      boolean lhsIsZero = lhs.signum() == 0;
      boolean augendIsZero = augend.signum() == 0;

      if (lhsIsZero || augendIsZero) {
        // 减数与被减数之一的精度为0
        int preferredScale = Math.max(lhs.scale(), augend.scale());
        BigDecimal result;

        if (lhsIsZero && augendIsZero)
          return zeroValueOf(preferredScale);
        // 减数精度为0，那么返回被减数四舍五入的结果，反之减数四舍五入结果
        result = lhsIsZero ? doRound(augend, mc) : doRound(lhs, mc);

        if (result.scale() == preferredScale)
          return result;
        else if (result.scale() > preferredScale) {
          return stripZerosToMatchScale(result.intVal, result.intCompact, result.scale, preferredScale);
        } else { // result.scale < preferredScale
          int precisionDiff = mc.precision - result.precision();
          int scaleDiff     = preferredScale - result.scale();
          if (precisionDiff >= scaleDiff)
            return result.setScale(preferredScale); // can achieve target scale
          else
            return result.setScale(result.scale() + precisionDiff);
        }
      }
    }

    // 减数与被减数的精度差
    long padding = (long) lhs.scale - augend.scale;
    if (padding != 0) { // scales differ; alignment needed
      // 两者精度差不为0，需要对两者的，返回值时一个BigDecimal数组，第一个元素是精度较大者
      BigDecimal arg[] = preAlign(lhs, augend, padding, mc);
      // 设置减数与被减数的标量一致
      matchScale(arg);
      lhs = arg[0];
      augend = arg[1];
    }
    // 运算结果
    return doRound(lhs.inflated().add(augend.inflated()), lhs.scale, mc);
  }

public class TestBigDecimal {
  public static void main(String[] args) {
    test1();
  }

  private static void test1(){
    BigDecimal valueSec = new BigDecimal(1000000);
    BigDecimal valueFir = new BigDecimal(1000000);
    BigDecimal valueThi = new BigDecimal(-1000000);

    //尽量用字符串的形式初始化
    BigDecimal stringFir = new BigDecimal("0.005");
    BigDecimal stringSec = new BigDecimal("1000000");
    BigDecimal stringThi = new BigDecimal("-1000000");

    //加法
    BigDecimal addVal = valueFir.add(valueSec);
    System.out.println("加法用value结果：" + addVal);
    BigDecimal addStr = stringFir.add(stringSec);
    System.out.println("加法用string结果：" + addStr);

    //减法
    BigDecimal subtractVal = valueFir.subtract(valueSec);
    System.out.println("减法value结果：" + subtractVal);
    BigDecimal subtractStr = stringFir.subtract(stringSec);
    System.out.println("减法用string结果：" + subtractStr);

    //乘法
    BigDecimal multiplyVal = valueFir.multiply(valueSec);
    System.out.println("乘法用value结果：" + multiplyVal);
    BigDecimal multiplyStr = stringFir.multiply(stringSec);
    System.out.println("乘法用string结果：" + multiplyStr);

    //绝对值
    BigDecimal absVal = valueThi.abs();
    System.out.println("绝对值用value结果：" + absVal);
    BigDecimal absStr = stringThi.abs();
    System.out.println("绝对值用string结果：" + absStr);

    //除法
    BigDecimal divideVal = valueSec.divide(valueFir, 20, BigDecimal.ROUND_HALF_UP);
    System.out.println("除法用value结果：" + divideVal);
    BigDecimal divideStr = stringSec.divide(stringFir, 20, BigDecimal.ROUND_HALF_UP);
    System.out.println("除法用string结果：" + divideStr);

  }

}

加法用value结果：2000000
加法用string结果：1000000.005
减法value结果：0
减法用string结果：-999999.995
乘法用value结果：1000000000000
乘法用string结果：5000.000
绝对值用value结果：1000000
绝对值用string结果：1000000
除法用value结果：1.00000000000000000000
除法用string结果：200000000.00000000000000000000