BigDecimal解读

1. BigDecimal概述

Java在java.math包中提供的API类BigDecimal，用来对超过16位有效位的数进行精确的运算。双精度浮点型变量double可以处理16位有效数，但在实际应用中，可能需要对更大或者更小的数进行运算和处理。一般情况下，对于那些不需要准确计算精度的数字，我们可以直接使用Float和Double处理，但是Double.valueOf(String) 和Float.valueOf(String)会丢失精度。所以开发中，如果我们需要精确计算的结果，则必须使用BigDecimal类来操作。
​ BigDecimal所创建的是对象，故我们不能使用传统的+、-、*、/等算术运算符直接对其对象进行数学运算，而必须调用其相对应的方法。方法中的参数也必须是BigDecimal的对象。构造器是类的特殊方法，专门用来创建对象，特别是带有参数的对象。

2. BigDecimal源码解读

BigDecimal实际上是由一个整数和一个小数位数scale表示的，这种方法避免了float 和 double小数精度问题

public class BigDecimal extends Number implements Comparable<BigDecimal> {
	// 当整数域的值部分超过Long.MIN_VALUE时，整数域用intVal表示
	private final BigInteger intVal; 
	// 当整数域的值部分不超过Long.MIN_VALUE时，整数域用intCompact表示
	private final transient long intCompact;
	// 表示小数位数
	private final int scale;
	// 表示值的有效位数，不包含正负符号
	private transient int precision;
	//表示值的字符串缓存，该值只赋值一次。
	private transient String stringCache;

	// 常用构造函数，通常建议使用字符串入参的构造函数
	public BigDecimal(String val) {
    	this(val.toCharArray(), 0, val.length());
	}
    public BigDecimal(int val) {
        this.intCompact = val;
        this.scale = 0;
        this.intVal = null;
    }
    public BigDecimal(long val) {
        this.intCompact = val;
        this.intVal = (val == INFLATED) ? INFLATED_BIGINT : null;
        this.scale = 0;
    }
	public BigDecimal(BigInteger val) {
        scale = 0;
        intVal = val;
        intCompact = compactValFor(val);
    }
	// 终极构造函数
	public BigDecimal(char[] in, int offset, int len, MathContext mc) {
		// 代码较长，详见源码
	}

	// 常用方法
	add(BigDecimal)
	subtract(BigDecimal)
	multiply(BigDecimal)
	divide(BigDecimal)
	toString()
	doubleValue()
	floatValue()
	longValue()
	intValue()

	public boolean equals(Object x) {
        if (!(x instanceof BigDecimal))
            return false;
        BigDecimal xDec = (BigDecimal) x;
        if (x == this)
            return true;
        // 若scale不相等，则不等
        if (scale != xDec.scale)
            return false;
        long s = this.intCompact;
        long xs = xDec.intCompact;
        if (s != INFLATED) {
            if (xs == INFLATED)
                xs = compactValFor(xDec.intVal);
            return xs == s;
        } else if (xs != INFLATED)
            return xs == compactValFor(this.intVal);

        return this.inflated().equals(xDec.inflated());
    }

	public int compareTo(BigDecimal val) {
        // Quick path for equal scale and non-inflated case.
        if (scale == val.scale) {
            long xs = intCompact;
            long ys = val.intCompact;
            if (xs != INFLATED && ys != INFLATED)
                return xs != ys ? ((xs > ys) ? 1 : -1) : 0;
        }
        // 数字符号，signum，-1，0，1分别表示负数，0，正数
        int xsign = this.signum(); 
        int ysign = val.signum();
        if (xsign != ysign)
            return (xsign > ysign) ? 1 : -1;
        if (xsign == 0)
            return 0;
		// 比较实际的值
        int cmp = compareMagnitude(val); 
        return (xsign > 0) ? cmp : -cmp;
    }
}

3. BigDecimal使用

// 3.1 构造函数尽量使用String的构造,例如，如果使用double构造函数，就会出现下面这种情况，因为double其实无法准确的表示0.1、真实的值(二进制表示)其实是0.1000000000000000055511151231257827021181583404541015625，0.1只是其丢失精度之后的值；而通过String构造的0.1就是真实的0.1，因此d1是不等于d2的。
BigDecimal d1 = new BigDecimal("0.1");
BigDecimal d2 = new BigDecimal(0.1d);
System.out.println(d1); // 0.1
System.out.println(d2); //0.1000000000000000055511151231257827021181583404541015625

// 3.2 scale()
BigDecimal d1 = new BigDecimal("123456.23100"); // 123456.231
BigDecimal d2 = new BigDecimal("12345678901234567890.12"); // 12345678901234567890.12
BigDecimal d3 = new BigDecimal("123400"); // 123400
// scale()获取小数位数
System.out.println(d1.scale()); // 5,两位小数
System.out.println(d2.scale()); // 2
System.out.println(d3.scale()); // 0
// 通过BigDecimal的stripTrailingZeros()方法，可以将一个BigDecimal格式化为一个相等的，但去掉了末尾0的BigDecimal：
System.out.println(d1.stripTrailingZeros().scale()); // 3
System.out.println(d3.stripTrailingZeros().scale()); // -2,此时表示d3是一个整数且默认带有两个0

// 3.3 加、减、乘时，精度不会丢失，但是做除法时，存在无法除尽的情况，这时，就必须指定精度以及如何进行截断
BigDecimal d1 = new BigDecimal("123.456");
BigDecimal d2 = new BigDecimal("23.456789");
BigDecimal d3 = d1.divide(d2, 10, RoundingMode.HALF_UP); // 保留10位小数并四舍五入
BigDecimal d4 = d1.divide(d2); // 报错：ArithmeticException，因为除不尽

// 总是使用compareTo()比较两个BigDecimal的值，不要使用equals()！因为两个BigDecimal相等不仅是值相等，小数位数也要相等。
BigDecimal bigDecimal1 = new BigDecimal("1.0");
BigDecimal bigDecimal2 = new BigDecimal("1.00");
System.out.println(bigDecimal1.equals(bigDecimal2)); // false, scale不等
System.out.println(bigDecimal1.compareTo(bigDecimal2)); // 0,相等

4. 特点

优点：能进行超过16位有效位的数进行精确的运算，精度不会丢失
缺点：BigDecimal每次计算都要创建对象，这个与BigInteger类似，其性能比double和float差，在处理庞大，复杂的运算时尤为明显。故一般精度的计算没必要使用BigDecimal。

5. BigDecimal总结

1）BigDecimal用于表示精确的小数，常用于财务或商业计算
2）尽量使用参数类型为String的构造函数
3）BigDecimal也是从Number继承的，也是不可变对象。在进行每一步运算时，都会产生一个新的对象，所以在做加减乘除运算时千万要保存操作后的值。
4）比较BigDecimal的值是否相等，必须使用compareTo()而不能使用equals()
5）除法使用时，要加上精度和舍入类型入参，避免除不尽报ArithmeticException异常