Java浮点数详解（double float）-- 分分搞定浮

初学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。

---