浮点数（double、float）处理问题时包含的隐晦的坑

具体现象

在处理涉及订单金额、商品交易、货币换算等有一定数据精度要求的数据时候，当使用float或者double这两种浮点型数据处理的话，总会偶现一些奇奇怪怪的问题，不知道大家注意没，下面举几个常见的例子：

//现象（一）：条件判断超预期
System.out.println( 1f == 0.9999999f );   // 打印：false
System.out.println( 1f == 0.99999999f );  // 打印：true  

//现象（二）：数据转换超预期
float f = 1.1f;
double d = (double) f;
System.out.println(f);  // 打印：1.1
System.out.println(d);  // 打印：1.100000023841858  

//现象（三）：基本运算超预期
System.out.println( 0.2 + 0.7);  // 打印：0.8999999999999999  

//现象（四）：数据自增超预期
float f1 = 8455263f;
for (int i = 0; i < 10; i++) {
    System.out.println(f1);
    f1++;
}
// 打印：8455263.0
// 打印：8455264.0
// 打印：8455265.0
// 打印：8455266.0
// 打印：8455267.0
// 打印：8455268.0
// 打印：8455269.0
// 打印：8455270.0
// 打印：8455271.0
// 打印：8455272.0

float f2 = 84552631f;
for (int i = 0; i < 10; i++) {
    System.out.println(f2);
    f2++;
}
//    打印：8.4552632E7   
//    打印：8.4552632E7   
//    打印：8.4552632E7   
//    打印：8.4552632E7   
//    打印：8.4552632E7   
//    打印：8.4552632E7   
//    打印：8.4552632E7   
//    打印：8.4552632E7   
//    打印：8.4552632E7   
//    打印：8.4552632E7   

可见以上操作都是最基本的数据运算，但是即使是如此简单的使用场景，也避免不了会有个别的数据，会到达数据类型范围边界的情况。

原因分析

我们先以第一个现象分析一下：

System.out.println( 1f == 0.99999999f );  // 打印：true

直接用上面两个float类型的数据进行比较，输出的结果竟然是true！但是反观以下这种少了一位数的情况，反而输出了false：

System.out.println( 1f == 0.9999999f );   // 打印：false

以上这种情况说明了机器根本无法区分这两个数，所以这是为啥呢？

我们知道输入的这两个浮点数只是我们人类肉眼所看到的具体数值，是我们通常所理解的十进制数，但是计算机底层在计算时可不是按照十进制来计算的，学过基本计组原理的都知道，计算机底层最终都是基于像010100100100110011011这种0、1二进制来完成的。

所以为了搞懂以上这种情况，我们要将两个十进制的浮点数转化为机器所识别的二进制看一看：

1f（十进制）
    ↓
00111111 10000000 00000000 00000000（二进制）

0.99999999f（十进制）
    ↓
00111111 10000000 00000000 00000000（二进制）

0.9999999f（十进制）
    ↓
00111111 01111111 11111111 11111110（二进制）

果然，在机器的角度看，二进制表示下的1f与0.99999999f是没有区别的，所以返回true。同理可得出另外一种返回false。

但是，为什么0.99999999f的二进制表示会跟1f的一样呢？这就要谈一下浮点数的精度问题了。

float和double这两种浮点数在内存中的存储结构如下所示：

1、符号部分（S）

· 0 -表示正数。
· 1 -表示负数。

2、阶码部分（E）（指数部分）：

· 对于float型浮点数，指数部分8位，考虑可正可负，因此可以表示的指数范围为-127 ~ 128。

· 对于double型浮点数，指数部分11位，考虑可正可负，因此可以表示的指数范围为-1023 ~ 1024。

3、尾数部分（M）：

浮点数的精度是由尾数的位数来决定的：

· 对于float型浮点数，尾数部分23位，换算成十进制就是 2^23=8388608，所以十进制精度只有6 ~ 7位；

· 对于double型浮点数，尾数部分52位，换算成十进制就是 2^52 = 4503599627370496，所以十进制精度只有15 ~ 16位。

对应上面的数值0.99999999f，很明显已经超出了float类型的精度范围，所以出现问题是难免的。

而对于上面所说的第二种现象：

//现象（二）：数据转换超预期
float f = 1.1f;
double d = (double) f;
System.out.println(f);  // 打印：1.1
System.out.println(d);  // 打印：1.100000023841858  

对于机器而言，将float转换成double，需要先将 1.1f 转换成float类型的二进制，然后再对后面所缺的位数进行补零从而转换成double类型的二进制；问题就出在前者，首先，1.1二进制的完整表示如下：

但是float类型只取了前23位，并且机器将最后一位进行了加一操作，类似于四舍五入，所以就出现了以下的情况：

然后对后19位进行补零操作，最后出现了这种情况，

System.out.println(d);  // 打印：1.100000023841858  

所以问题的关键就是机器做了类型转换，而另外一种情况则没有做数据类型转换，而是直接输出：

System.out.println(f);  // 打印：1.1

而对于现象三，则是因为做了数据转换以后，double类型尾数的52位不足以全部表示0.2与0.7的二进制位数，所以导致机器只截取了前52位进行运算，最后导致了精度丢失的情况。

而对于现象四，则是因为该数据自增后超过了float类型指数部分的8位数限制，导致自增看上去无效的现象。

解决方法

方法一：用字符串或者数组解决多位数的问题

我们可以用字符串或者数组来表示这类型多位数，然后按照四则运算的规则来手动模拟出具体计算过程，不过中间还需要考虑各种诸如：进位、借位、符号等等问题的处理，过程稍显复杂。

方法二：Java的大数类

JDK早已为我们考虑到了浮点数的计算精度问题，因此提供了专用于高精度数值计算的大数类来方便我们使用。

Java的大数类位于java.math包下：

可以看到，常用的BigInteger 和 BigDecimal就是处理高精度数值计算的利器，我们再次使用上面的数据：

BigDecimal num3 = new BigDecimal( Double.toString( 1.0 f ) );
BigDecimal num4 = new BigDecimal( Double.toString( 0.99999999f ) );
System.out.println( num3 == num4 );  // 打印 false

BigDecimal num1 = new BigDecimal( Double.toString( 0.2 ) );
BigDecimal num2 = new BigDecimal( Double.toString( 0.7 ) );

// 加
System.out.println( num1.add( num2 ) );  // 打印：0.9

// 减
System.out.println( num2.subtract( num1 ) );  // 打印：0.5

// 乘
System.out.println( num1.multiply( num2 ) );  // 打印：0.14

// 除
System.out.println( num2.divide( num1 ) );  // 打印：3.5

当然了，像BigInteger 和 BigDecimal这种大数类的运算效率肯定是不如原生类型效率高，代价还是比较昂贵的，是否选用需要根据实际场景来评估。