java浮点类型（float，double）运算精度问题原因附解决方案代码

在java中运行如下代码：

public static void main(String[] args) {
		System.out.println("0.01 + 0.05 = " + (0.01+0.05));
		System.out.println("0.1 + 0.2 = " + (0.1+0.2));
		System.out.println("9948.5 + 1292.12 = " + (9948.5+1292.12));
	}

会得到如下结果

0.01 + 0.05 = 0.060000000000000005
0.1 + 0.2 = 0.30000000000000004
9948.5 + 1292.12 = 11240.619999999999

产生这个问题的原因是：
二进制是无法精准表示一些小数的，如表示0.1时就会产生无限制的0和1的循环，而jvm为每个数字分配的内存是有限的，所以最终得到的数值只是接近0.1的小数。

这种运算问题不仅在Java中存在，在js，python中都存在，但每种语言都存在解决方法。

java的解决方法就是使用BigDecimal代替浮点类型进行计算。
使用BigDecimal.valueOf(param)或BigDecimal的构造传入数值作参数都可以实例化出一个BigDecimal对象，然后使用其add(param),subtract（param）,multiply(param),divide(param)就可以实现加减乘除运算了。
这也是金额为什么一定要使用BigDecimal来表示的原因了。

最后附一个BigDecimal的运算工具类

public final class BigDecimalArithUtil {

	/**
	 * 这个类不能实例化
	 */
	private BigDecimalArithUtil(){
	}

	/**
	 * 提供精确的加法运算。
	 * @param v1 被加数
	 * @param v2 加数 可变参数
	 * @return n个参数的和
	 */
	public static double add(double v1,double ... v2){
		BigDecimal b1 = new BigDecimal(Double.toString(v1));
		for (double v : v2) {
			b1 = b1.add(BigDecimal.valueOf(v));
		}
		return b1.doubleValue();
	}
	/**
	 * 提供精确的减法运算。
	 * @param v1 被减数
	 * @param v2 减数 可变参数
	 * @return 差
	 */
	public static double sub(double v1,double ... v2){
		BigDecimal b1 = new BigDecimal(Double.toString(v1));
		for (double v : v2) {
			b1 = b1.subtract(BigDecimal.valueOf(v));
		}
		return b1.doubleValue();
	}
	/**
	 * 提供精确的乘法运算。
	 * @param v1 被乘数
	 * @param v2 乘数 可变参数
	 * @return 积
	 */
	public static double mul(double v1,double ... v2){
		BigDecimal b1 = new BigDecimal(Double.toString(v1));
		for (double v : v2) {
			b1 = b1.multiply(BigDecimal.valueOf(v));
		}
		return b1.doubleValue();
	}

	/**
	 * 提供（相对）精确的除法运算。当发生除不尽的情况时，由scale参数指
	 * 定精度，以后的数字四舍五入。
	 * @param v1 被除数
	 * @param v2 除数  可变参数
	 * @param scale 表示表示需要精确到小数点以后几位。
	 * @return 商
	 */
	public static double div(int scale,double v1,double ... v2){
		if(scale<0){
			throw new IllegalArgumentException(
					"The scale must be a positive integer or zero");
		}
		BigDecimal b1 = new BigDecimal(Double.toString(v1));
		for (double v : v2) {
			b1 = b1.divide(BigDecimal.valueOf(v),scale,BigDecimal.ROUND_HALF_UP);
		}
		return b1.doubleValue();
	}
	/**
	 * 提供精确的小数位四舍五入处理。
	 * @param v 需要四舍五入的数字
	 * @param scale 小数点后保留几位
	 * @return 四舍五入后的结果
	 */
	public static double round(double v,int scale){
		if(scale<0){
			throw new IllegalArgumentException(
					"The scale must be a positive integer or zero");
		}
		BigDecimal b = new BigDecimal(Double.toString(v));
		BigDecimal one = new BigDecimal("1");
		return b.divide(one,scale,BigDecimal.ROUND_HALF_UP).doubleValue();
	}
}