初学Java只简单听说double,float是不能精确的表示一个数，然后留下满满的疑问？ why? 这个问题已经放了好久时间了，今天终于把这个问题整明白了！首先整理一下以下几个困惑
1.浮点数（double float）真的会不精确？
我们在使用的过程中并没有误差啊？
double a = 0.4;
double b = a*4;
System.out.println(b); // 输出 1.6
// 不是说浮点数不精确吗？那我们做一个相等判断
System.out.println(a == 0.4); //输出 true
// 我去，哪有什么不精确！！！瞎BB
当我们放心大胆的用浮点数时
System.out.println (0.4 * 0.2);
// 输出 0.08000000000000002
System.out.println(40000000.0f == 40000000.5f); // float类型字面量
// 输出 true
System.out.println(4000000000000000.0 == 4000000000000000.2);
// 输出 true
// 啊西巴！ 什么情况
2.浮点数为什么会不精确?
粗浅的解释：
1. double 的取值范围 [-1.79 e+308 , 1.79 e+308] 。但 double 的存储空间为 8 字节一共 64 位，也就是说 double 最多可以用 2∧64 个不同值来表示不同区间，约等于 1.84 e+19 个区间。
这也是为什么 40000000.0 f = 40000000.5 f， 4000000000000000.0 = 4000000000000000.2 ，因为他们在同一个区间。
2. 每一个区间都会用一个值来显示，但这个显示值（在这个区间的值都用这个值显示）与存储值（存储在计算机中二进制所表示的值）并不一定相等。（“ 整数 ” 显示值 = 储存值，所以下面只讨论 “ 小数 ”）
显示值 (double) 储存值 (double)
0.5 0.5
0.4 0.40000000000000002220446049250313080847263336181640625
0.25 0.25
0.2 0.200000000000000011102230246251565404236316680908203125
什么时候 显示值 会与 储存值 相等呢？ 这里有一个规律
有一个小于 1 的小数 d ，如果满足 d*2∧n = 1 则 d 的 显示值 等与 储存值 。( n 为正整数)
比如: 0.5 * 2 = 1 , 0.25 * 2 * 2 = 1 , 0.125 * 2 * 2 * 2 = 1
为什么会有这个规律，可以了解小数的二进制表示 。
计算和比较时用的是 储存值，最终以 计算结果所在区间的 显示值 显示在屏幕上；
显示值 (double) 储存值 (double)
0.4 0.40000000000000002220446049250313080847263336181640625
0.2 0.200000000000000011102230246251565404236316680908203125
接下来我们可以解释：0.4 * 0.2 = 0.08000000000000002
a = (0.4的储存值) 0.40000000000000002220446049250313080847263336181640625;
b = (0.2的储存值) 0.200000000000000011102230246251565404236316680908203125;
a * b ≈ 0.08000000000000000888178419700125256990808622629275169;
计算结果需要存储，它所在区间对应的 储存值 为 :
0.080000000000000015543122344752191565930843353271484375
该 存储值 对应的 显示值 为:
0.08000000000000002
3.误差累积效应（重点）
浮点数因为计算时是用 储存值 多次计算，有可能会放大误差。
System.out.println(0.4 * 0.4 * 0.4); // 输出 0.06400000000000002
System.out.println(0.5 * 0.5 * 0.5); // 输出 0.125
注意是有可能不是一定，有两种情况；
1. （显示值 = 储存值） ，这样多次计算没有误差，除非计算中出现数值的有效位数过长，double类型不能表示，会出现精度丢失的情况
2. （显示值 > 储存值） 与 （显示值 < 储存值）混合运算，它们的误差会相互抵消
3.浮点数使用场景
一般来说浮点数使用比较方便，误差比较小( 可以忽略 )，计算机操作浮点数的效率高( 与BigDecimal相比较)，所以浮点数挺常用的。但使用它必须 慎重 考虑以下情况：
1. 数值的有效位数过长，会发生精度丢失；
2. 数值较大，误差也会变大了；
0.40000000000000000000000 = 0.40000000000000002220446
（在同一个区间，储存值都为 0.40000000000000002220446049250313080847263336181640625 所以相等）
40000000000000000000000.0 = 40000000000000002220446.0
（在同一个区间，储存值都为 40000000000000000000000 所以相等）
3. 浮点数的 误差累积效应；
4. 该数值表示的类型是否对误差有严格的要求，（比如：时间，金钱）
4.该如何进行精确的计算
Java要进行精确计算，需要使用到类java.math.Big。借助BigDecima可以查看浮点数的储存值；
BigDecimal b1 = new BigDecimal( 0.4 ); // double类型字面量
BigDecimal b2 = new BigDecimal( 0.4f ); // float类型字面量
System.out.println( b1 ); // 输出 0.40000000000000002220446049250313080847263336181640625
System.out.println( b2 ); // 输出 0.4000000059604644775390625
哇卡卡，通过上面的案例，可以发现 BigDecima 真强大！！不过用它做计算有点麻烦
publicBigDecimal add(BigDecimal value);//加法
publicBigDecimal subtract(BigDecimal value);//减法
publicBigDecimal multiply(BigDecimal value);//乘法
publicBigDecimal divide(BigDecimal value);//除法
BigDecimal b1 = new BigDecimal("0.4");
BigDecimal b2 = new BigDecimal("0.2");
System.out.println(b1.add(b2)); // 输出 0.6
System.out.println(b1.subtract(b2)); // 输出 0.2
System.out.println(b1.multiply(b2)); // 输出 0.08
System.out.println(b1.divide(b2)); // 输出 2
若要详细了解BigDecima，请查看API。
