乐趣区

关于java:为什么浮点精度运算会有问题

jiezi

为什么浮点精度运算会有问题

咱们平时应用的编程语言大多都有一个问题——浮点型精度运算会不精确。比方



1.  double num = 0.1 + 0.1 + 0.1;
    
2.  // 输入后果为 0.30000000000000004
    
3.  double num2 = 0.65 - 0.6;
    
4.  // 输入后果为 0.05000000000000004

笔者在测试的时候发现 C/C++ 居然不会呈现这种问题，我最后认为是编译器优化，把这个问题解决了。然而 C/C++ 如果能解决其余语言为什么不跟进？依据这个问题的产生起因来看，编译器优化解决这个问题逻辑不通。起初发现是打印的办法有问题，打印输出办法会四舍五入。应用 printf("%0.17fn", num); 以及 cout << setprecision(17) << num2 << endl; 多打印几位小数即可看到精度运算不精确的问题。

那么精度运算不精确这是为什么呢？咱们接下来就须要从计算机所有数据的表现形式二进制说起了。如果大家很理解二进制与十进制的互相转换，那么就能轻易的晓得精度运算不精确的问题起因是什么了。如果不晓得就让咱们一起回顾一下十进制与二进制的互相转换流程。个别状况下二进制转为十进制咱们所应用的是 按权相加法 。十进制转二进制是 除 2 取余，逆序排列法。很熟的同学能够略过。



1.  // 二进制到十进制
    
2.  10010 = 0 * 2^0 + 1 * 2^1 + 0 * 2^2 + 0 * 2^3 + 1 * 2^4 = 18  
    

4.  // 十进制到二进制
    
5.  18 / 2 = 9 .... 0 
    
6.  9 / 2 = 4 .... 1 
    
7.  4 / 2 = 2 .... 0 
    
8.  2 / 2 = 1 .... 0 
    
9.  1 / 2 = 0 .... 1
    

11.  10010

那么，问题来了十进制小数和二进制小数是如何互相转换的呢？十进制小数到二进制小数个别是 整数局部除 2 取余，逆序排列 ， 小数局部应用乘 2 取整数位，顺序排列 。二进制小数到十进制小数还是应用 按权相加法。



1.  // 二进制到十进制
    
2.  10.01 = 1 * 2^-2 + 0 * 2^-1 + 0 * 2^0 + 1 * 2^1 = 2.25
    

4.  // 十进制到二进制
    
5.  // 整数局部
    
6.  2 / 2 = 1 .... 0
    
7.  1 / 2 = 0 .... 1
    
8.  // 小数局部
    
9.  0.25 * 2 = 0.5 .... 0 
    
10.  0.5 * 2 = 1 .... 1 
    

12.  // 后果 10.01

转小数咱们也理解了，接下来咱们回归正题，为什么浮点运算会有精度不精确的问题。接下来咱们看一个简略的例子 2.1 这个十进制数转成二进制是什么样子的。



1.  2.1 分成两局部
    
2.  // 整数局部
    
3.  2 / 2 = 1 .... 0
    
4.  1 / 2 = 0 .... 1
    

6.  // 小数局部
    
7.  0.1 * 2 = 0.2 .... 0
    
8.  0.2 * 2 = 0.4 .... 0
    
9.  0.4 * 2 = 0.8 .... 0
    
10.  0.8 * 2 = 1.6 .... 1
    
11.  0.6 * 2 = 1.2 .... 1
    
12.  0.2 * 2 = 0.4 .... 0
    
13.  0.4 * 2 = 0.8 .... 0
    
14.  0.8 * 2 = 1.6 .... 1
    
15.  0.6 * 2 = 1.2 .... 1
    
16.  0.2 * 2 = 0.4 .... 0
    
17.  0.4 * 2 = 0.8 .... 0
    
18.  0.8 * 2 = 1.6 .... 1
    
19.  0.6 * 2 = 1.2 .... 1
    
20.  ............

落入有限循环后果为 10.0001100110011……..，咱们的计算机在存储小数时必定是有长度限度的，所以会进行截取局部小数进行存储，从而导致计算机存储的数值只能是个大略的值，而不是准确的值。从这里看进去咱们的计算机基本就无奈应用二进制来准确的示意 2.1 这个十进制数字的值，连示意都无奈准确示意进去，计算必定是会呈现问题的。

精度运算失落的解决办法

现有有三种方法

  1. 如果业务不是必须十分准确的要求能够采取四舍五入的办法来疏忽这个问题。
  2. 转成整型再进行计算。
  3. 应用 BCD 码存储和运算二进制小数(感兴趣的同学可自行搜寻学习)。

个别每种语言都用高精度运算的解决办法（比个别运算消耗性能），比方 Python 的 decimal 模块，Java 的 BigDecimal，然而肯定要把小数转成字符串传入结构，不然还是有坑，其余语言大家能够自行寻找一下。



1.  # Python 示例
    
2.  from decimal import Decimal
    

4.  num = Decimal('0.1') + Decimal('0.1') + Decimal('0.1')
    
5.  print(num)
    




1.  // Java 示例
    
2.  import java.math.BigDecimal;
    

4.  BigDecimal add = new BigDecimal("0.1").add(new BigDecimal("0.1")).add(new BigDecimal("0.1"));
    
5.  System.out.println(add);

拓展：详解浮点型

下面既然提到了浮点型的存储是有限度，那么咱们看一下咱们的计算机是如何存储浮点型的，是不是真的正如咱们下面提到的有小数长度的限度。
那咱们就以 Float 的数据存储构造来说，依据 IEEE 规范浮点型分为符号位，指数位和尾数位三局部（各局部大小详情见下图）。

IEEE 754 规范

个别状况下咱们示意一个很大或很小的数通常应用迷信记数法，例如：1000.00001 咱们个别示意为 1.00000001 10^3，或者 0.0001001 个别示意为 1.001 10^-4。

符号位

0 是负数，1 是正数

指数位

指数很有意思因为它须要示意正负，所以人们发明了一个叫 EXCESS 的零碎。这个零碎是什么意思呢？它规定 最大值 / 2 – 1 示意指数为 0。咱们应用单精度浮点型举个例子，单精度浮点型指数位一共有八位，示意的十进制数最大就是 255。那么 255 / 2 – 1 = 127，127 就代表指数为 0。如果指数位存储的十进制数据为 128 那么指数就是 128 – 127 = 1，如果存储的为 126，那么指数就是 126 – 127 = -1。

尾数位

比方上述例子中 1.00000001 以及 1.001 就属于尾数，然而为什么叫尾数呢？因为在二进制中比方 1.xx 这个小数，小数点后面的 1 是永远存在的，存了也是节约空间不如多存一位小数，所以尾数位只会存储小数局部。也就是上述例子中的 00000001 以及 001 存储这样的数据。

IEEE 754 规范

通过上述程序咱们失去的存储 1.25 的 float 二进制构造的具体值为 00111111101000000000000000000000，咱们拆分一下 0 为符号位他是个正值。01111111 为指数位，01000000000000000000000 是尾数。接下来咱们验证一下 01111111 转为十进制是 127，那么通过计算指数为 0。尾数是 01000000000000000000000 加上默认省略的 1 为 1.01（省略前面多余的 0），转换为十进制小数就是 1.25。

参考：《2020 最新 Java 根底精讲视频教程和学习路线！》

退出移动版