在计算金额的时候，实际上整数，浮点数有时候有点捉襟见肘。于是math包提供了一个Bigdecimal类，所以可以学习一下这个BigDecimal的源码和使用。
首先是看一下他的构造方法：
看起来构建的方式很多，但实际上之间的差别很大，举个例子就是构建一个BigDecimal，String，整型实际上是有差别的，不如下面例子打印的结果：
BigDecimal val = new BigDecimal(0.1);
System.out.println(val);
System.out.println(" === bigdecimal : " + val.toString());
BigDecimal val001 = new BigDecimal("0.1");
System.out.println(val001);
System.out.println(" === bigdecimal : " + val001.toString());
输出结果：
0.1000000000000000055511151231257827021181583404541015625
=== bigdecimal : 0.1000000000000000055511151231257827021181583404541015625
0.1
=== bigdecimal : 0.1
第一个输出主要原因还是中间转换浮点数精度的问题导致的，中间强行塞了一个所谓的“无限精度算术需要的值，还做了向上的五入”。
BigDecimal的运算
实际上BigDecimal的运算和别的基本类型包装类还不同，是通过类里面的方法来操作，中间为了保证格式还可以选择舍入模式。
add(BigDecimal) BigDecimal对象中的值相加，然后返回这个对象。
subtract(BigDecimal) BigDecimal对象中的值相减，然后返回这个对象。
multiply(BigDecimal) BigDecimal对象中的值相乘，然后返回这个对象。
divide(BigDecimal) BigDecimal对象中的值相除，然后返回这个对象。
toString() 将BigDecimal对象的数值转换成字符串。
doubleValue() 将BigDecimal对象中的值以双精度数返回。
floatValue() 将BigDecimal对象中的值以单精度数返回。
longValue() 将BigDecimal对象中的值以长整数返回。
intValue() 将BigDecimal对象中的值以整数返回。
舍入模式：
// Rounding Modes
/**
* Rounding mode to round away from zero. Always increments the
* digit prior to a nonzero discarded fraction. Note that this rounding
* mode never decreases the magnitude of the calculated value.
*/
public final static int ROUND_UP = 0;
/**
* Rounding mode to round towards zero. Never increments the digit
* prior to a discarded fraction (i.e., truncates). Note that this
* rounding mode never increases the magnitude of the calculated value.
*/
public final static int ROUND_DOWN = 1;
/**
* Rounding mode to round towards positive infinity. If the
* {@code BigDecimal} is positive, behaves as for
* {@code ROUND_UP}; if negative, behaves as for
* {@code ROUND_DOWN}. Note that this rounding mode never
* decreases the calculated value.
*/
public final static int ROUND_CEILING = 2;
/**
* Rounding mode to round towards negative infinity. If the
* {@code BigDecimal} is positive, behave as for
* {@code ROUND_DOWN}; if negative, behave as for
* {@code ROUND_UP}. Note that this rounding mode never
* increases the calculated value.
*/
public final static int ROUND_FLOOR = 3;
/**
* Rounding mode to round towards {@literal "nearest neighbor"}
* unless both neighbors are equidistant, in which case round up.
* Behaves as for {@code ROUND_UP} if the discarded fraction is
* ≥ 0.5; otherwise, behaves as for {@code ROUND_DOWN}. Note
* that this is the rounding mode that most of us were taught in
* grade school.
*/
public final static int ROUND_HALF_UP = 4;
/**
* Rounding mode to round towards {@literal "nearest neighbor"}
* unless both neighbors are equidistant, in which case round
* down. Behaves as for {@code ROUND_UP} if the discarded
* fraction is {@literal >} 0.5; otherwise, behaves as for
* {@code ROUND_DOWN}.
*/
public final static int ROUND_HALF_DOWN = 5;
/**
* Rounding mode to round towards the {@literal "nearest neighbor"}
* unless both neighbors are equidistant, in which case, round
* towards the even neighbor. Behaves as for
* {@code ROUND_HALF_UP} if the digit to the left of the
* discarded fraction is odd; behaves as for
* {@code ROUND_HALF_DOWN} if it's even. Note that this is the
* rounding mode that minimizes cumulative error when applied
* repeatedly over a sequence of calculations.
*/
public final static int ROUND_HALF_EVEN = 6;
/**
* Rounding mode to assert that the requested operation has an exact
* result, hence no rounding is necessary. If this rounding mode is
* specified on an operation that yields an inexact result, an
* {@code ArithmeticException} is thrown.
*/
public final static int ROUND_UNNECESSARY = 7;