Java浮点数详解（double float）

Java浮点数详解（double float）

最佳答案 53678位专家为你答疑解惑

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。

15 张图带你深入理解浮点数

大家好，我是站长 polarisxu。

团队一直保持着分享的习惯，而我却分享的较少。忘了当时同事分享什么主题，涉及到浮点数相关知识。于是我决定分享一期关于浮点数的，而且 Go 之父 Rob Pike 说不懂浮点数不配当码农。。。So？！

本着「要学习就系统透彻的学」这个原则，本文通过图的方式尽可能详细的讲解浮点数，让大家能够对浮点数有一个更深层次的认识。

本文目录：

0、几个问题

开始之前请思考如下问题：

二进制 0.1，用十进制表示的话是多少？十进制的 0.1，用二进制表示又是多少？为什么 0.1 + 0.2=0.30000000000000004？单精度和双精度浮点数的有效小数位分别是多少？单精度浮点数能表示的范围是什么？浮点数为什么会存在 -0？infinity 和 NaN 又是怎么表示的？

如果现在不会，那这篇文章正好可以为你解惑。

1、什么是浮点数

我们知道，数学中并没有浮点数的概念，虽然小数看起来像浮点数，但从不这么叫。那为什么计算机中不叫小数而叫浮点数呢？

因为资源的限制，数学中的小数无法直接在计算机中准确表示。为了更好地表示它，计算机科学家们发明了浮点数，这是对小数的近似表示。维基百科中关于浮点数的概念说明如下：

The term floating point refers to the fact that a number's radix point (decimal point, or, more commonly in computers, binary point) can float; that is, it can be placed anywhere relative to the significant digits of the number.

也就是说浮点数是相对于定点数而言的，表示小数点位置是浮动的。比如 7.5 × 10、0.75 × 102 等表示法，值一样，但小数点位置不一样。

具体来说，浮点数是指用符号、尾数、基数和指数这四部分来表示的小数。

2、IEEE754 又是什么

知道了浮点数的概念，但需要确定一套具体的表示、运算标准。其中最有名的就是 IEEE754 标准。William Kahan 正是因为浮点数标准化的工作获得了图灵奖。

The IEEE Standard for Floating-Point Arithmetic (IEEE 754) is a technical standard for floating-point arithmetic established in 1985 by the Institute of Electrical and Electronics Engineers (IEEE). The standard addressed many problems found in the diverse floating-point implementations that made them difficult to use reliably and portably. Many hardware floating-point units use the IEEE 754 standard.

本文的讨论都基于 IEEE754 标准，这也是目前各大编程语言和硬件使用的标准。

根据上面浮点数的组成，因为是在计算机中表示浮点数，基数自然是 2，因此 IEEE754 浮点数只关注符号、尾数和指数三部分。

3、小数的二进制和十进制转换

为了方便后面的内容顺利进行，复习下二进制和十进制的转换，其中主要涉及到小数的转换。

二进制转十进制

和整数转换一样，采用各位数值和位权相乘。比如：

(0.101)?=1×2?1 + 0×2?2 + 0×2?3=(0.625)??

记住小数点后第一位是从 -1 开始即可。

十进制转二进制

十进制整数转二进制采用“除 2 取余，逆序排列”法。例如十进制数 11 转为二进制：

11/2=5…余15/2=2…余12/2=1…余01/2=0…余1

所以 (11)?? 的二进制是 (1011)?。

但如果十进制是小数，转为二进制小数如何做？采用“乘 2 取整，顺序排列”。例如十进制小数 0.625 转为二进制小数：

0.625*2=1.25…取整数部分10.25*2=0.5…取整数部分00.5*2=1…取整数部分1

顺序排列，所以 (0.625)??=(0.101)?。

为了方便大家快速的做转换，网上有很多这样的工具。推荐一个我觉得最棒的：https://baseconvert.com/，支持各进制的转换，还支持浮点数。

4、经典问题：0.1 + 0.2=0.30000000000000004

这个问题网上相关的讨论很多，甚至有专门的一个网站：https://0.30000000000000004.com/，这个网站上有各门语言的 0.1 + 0.2 的结果。比如 C 语言：

#include<stdio.h>intmain(intargc,char**argv){printf("%.17f\n",.1+.2);return0;}

Go 语言：

packagemainimport("fmt")funcmain(){vara,bfloat64=0.1,0.2fmt.Println(a+b)}

结果都是 0.30000000000000004。

为什么会这样？这要回到 IEEE754 标准关于浮点数的规定。

5、浮点数的 IEEE754 表示

上文提到，浮点数由四个部分构成，那 IEEE754 标准是如何规定它们的存储方式的呢？

一般地，IEEE754 浮点数有两种类型：单精度浮点数（float）和双精度浮点数（double），还有其他的，不常用。单精度浮点数使用 4 字节表示；双精度浮点数使用 8 字节表示。在 Go 语言中用 float32 和 float64 表示这两种类型。

符号位不用说，0 表示正数，1 表示负数。着重看指数部分和尾数部分。（基数前文说了，固定是 2，因此不存）

尾数部分

前面提到过，浮点数名称的由来在于小数点是浮动的。但具体存储时，需要固定一种形式，这叫做尾数的标准化。IEEE754 规定，在二进制数中，通过移位，将小数点前面的值固定为 1。IEEE754 称这种形式的浮点数为规范化浮点数（normal number）。

比如十进制数 0.15625，转为二进制是 0.00101。为了让第 1 位为 1，执行逻辑右移 3 位，尾数部分成为 1.01，因为右移了 3 位，所以指数部分是 -3。因为规定第 1 位永远为 1，因此可以省略不存，这样尾数部分多了 1 位，只需存 0100（要记住，这是的数字是小数点后的数字，因此实际是 0.01，转为十进制是 0.25 — 没算未存的小数点前面的 1）。

因此对于规范化浮点数，尾数其实比实际的多 1 位，也就是说单精度的是 24 位，双精度是 53 位。为了作区分，IEEE754 称这种尾数为 significand。

有规范化浮点数，自然会有非规范化浮点数（denormal number），这会在后文讲解。

请牢记，尾数决定了精度，对于单精度浮点数，因为只有 23 位，而1<<23 对应十进制是 8388608，因此不能完整表示全部的 7 个十进制位，所以说，单精度浮点数有效小数位最多 7 位；双精度的有效小数位是 15 位；切记切记，有精度问题！！

指数部分

因为指数有正、有负，为了避免使用符号位，同时方便比较、排序，指数部分采用了 The Biased exponent（有偏指数）。IEEE754 规定，2??1-1 的值是 0，其中 e 表示指数部分的位数，小于这个值表示负数，大于这个值表示正数。因此，对于单精度浮点数而言， 2??1-1=127 是 0；双精度浮点数，211?1-1=1023 是 0。

没看懂？举个栗子。

还是用十进制 0.15625 举例。上文知道，因为右移了 3 位，所以指数是 -3。根据 IEEE754 的定义，单精度浮点数情况下，-3 的实际值是 127 - 3=124。明白了吗？127 表示 0，124 就表示 -3 了。而十进制的 124 转为二进制就是 1111100。

如果你还不理解，想想这个问题。

如果让你用扑克牌（A ~ K，也就是 1 ~ 13）来表示支持负数的。怎么办？我们会选择一个中间的数，比如 7 当做 0，因此 10 就是 +3，4 就是 -3。现在理解了吧！

小结

结合尾数和指数的规定，IEEE754 单精度浮点数，十进制 0.15625 对应的二进制内存表示是：0 01111100 01000000000000000000000。

6、程序确认下 IEEE754 的如上规定

读到这里，希望你能坚持下去。为了进一步加深理解，我画一张图和一个确认程序。

一张图

这张图是单精度浮点数 0.15625 的内存存储表示。根据三部分的二进制表示，可以反推出计算该数的十进制表示。作为练习，十进制的 2.75，用上图表示的话，各个位置分别都是什么值呢？

程序确认单精度浮点数的内存表示

使用 Go 语言编写一个程序，能够得到一个单精度浮点数的二进制内存表示。比如提供单精度浮点数 0.15625，该程序能够输出：0-01111100-01000000000000000000000。

packagemainimport("fmt""math")funcmain(){varffloat32=0.15625outputFEEE754(f)}funcoutputFEEE754(ffloat32){//将该浮点数内存布局当做uint32看待（因为都占用4字节）//这里实际上是做强制转换，内部实现是：return *(*uint32)(unsafe.Pointer(&f))buf:=math.Float32bits(f)//加上两处-，结果一共34bytevarresult[34]byte//从低字节开始fori:=33;i>=0;i--{ifi==1||i==10{result[i]='-'}else{ifbuf%2==1{result[i]='1'}else{result[i]='0'}buf/=2}}fmt.Printf("%s\n",result)}//output:0-01111100-01000000000000000000000

你可以使用上述程序，验证下 2.75，看看你做对没有！提供了一个在线可运行版本：https://play.studygolang.com/p/pg0QNQtBHYx。

其实上面推荐的那个工具就能够得到十进制浮点数的二进制内存表示，地址：https://baseconvert.com/ieee-754-floating-point。

另外，在 Java 语言中也有类似的方法：Float.floatToIntBits()，你可以使用 Java 实现上面类似的功能。

6、再看 0.1+0.2=0.30000000000000004

有了上面的知识，我们回过头看看这个经典的问题。（讨论单精度的情况，因此实际是 0.1+0.2=0.300000004）

出错的原因

出现这种情况的根本原因是，有些十进制小数无法转换为二进制数。如下图：

在小数点后 4 位时，连续的二进制数，对应的十进制数却是不连续的，因此只能增加位数来尽可能近似的表示。

0.1 和 0.2 是如何表示的？

根据前面的讲解，十进制 0.1 转为二进制小数，得到的是 0.0001100… （重复1100）这样一个循环二进制小数，使用 IEEE754 表示如下图：

同样的方法，0.2 用单精度浮点数表示是：0.20000000298023223876953125。所以，0.1 + 0.2 的结果是：0.300000004470348358154296875。

7、特殊值

耐心的读者看到这里，你真的很棒！但还没完哦，继续加油！

单精度浮点数的最大值

讲解下一个知识点之前，请思考本文开始的一个问题：单精度浮点数的最大值是多少？

根据前面学到的知识，我们很容易想到它的最大值的内存应该表示是这样的。

即：01111111111111111111111111111111。然而我们把这个值填入 https://baseconvert.com/ieee-754-floating-point 中，发现结果是这样的：

什么？NaN 是个什么鬼？！我就是按照你上面讲过的思考的。。。

别急，因为凡是都有特殊。现在就讲讲浮点数中的特殊值。

特殊值 infinity（无穷）

当指数位全是 1，尾数位全是 0 时，这样的浮点数表示无穷。根据符号位，有正无穷和负无穷（+infinity 和 -infinity）。为什么需要无穷？因为计算机资源的限制，没法表示所有的数，当一个数超过了浮点数的表示范围时，就可以用 infinity 来表示。而数学中也有无穷的概念。

在 Go 语言中，通过 math 包的 func Inf(sign int) float64 函数可以获取到正负无穷。

在 Java 语言中，通过 Float 或 Double 类中的常量可以获得：Float.POSITIVE_INFINITY、Float.NEGATIVE_INFINITY。

具体表示可以定义一个常量，比如：

正无穷：0x7FF0000000000000，负无穷：0xFFF0000000000000

和上面浮点数内存位模型强转 int 类似，这个执行相反操作（类似 Float64frombits 这样的函数），就得到了这个特殊的浮点值。可以看 Go 语言 math 标准库相应函数的实现。

特殊值 NaN

NaN 是 not-a-number 的缩写，即不是一个数。为什么需要它？例如，当对 -1 进行开根号时，浮点数不知道如何进行计算，就会使用 NaN，表示不是一个数。

NaN 的具体内存表示是：指数位全是 1，尾数位不全是 0。

和 infinity 类似，Go 和 Java 都定义了相应的函数或常量。

小结

现在清楚上面单精度浮点数最大值是不对的了吧，它是一个 NaN。画一张图，方便你更清晰的记住这些特殊值。

所以单精度浮点数的最大值应该能确认了，即：0 11111110 11111111111111111111111。

8、非规范化浮点数

接着用问题的方式继续：单精度浮点数的最小值是多少（正数）？

根据前面的知识，我们会得到这样的最小值：0 00000000 00000000000000000000001。根据前面规范化浮点数的规定，我们知晓该值是：2?12?×(1+2?23)。

然而，最小值的内存表示没错，但算出来的结果是错的。（额头冒汗没？怎么又错了~）

为了避免两个小浮点数相减结果是 0（也就是规范化浮点数无法表示）这样情况出现，同时根据规范化浮点数的定义，因为尾数部分有一个省略的前导 1，因此无法表示 0。所以，IEEE754 规定了另外一种浮点数：

当指数位全是 0，尾数部分不全为 0，尾数部分没有省略的前导 1，同时指数部分的偏移值比规范形式的偏移值小 1，即单精度是 -126，双精度是 -2046。这种形式的浮点数叫非规范化浮点数（denormal number）。

因此单精度浮点数的最小值（正数）如下图：

有了非规范化浮点数，IEEE754 就可以表示 0 了，但会存在 +0 和 -0：即所有位全是 0 时是 +0；符号位是 1，其他位是 0 时是 -0。

9、IEEE754 浮点数分类小结

至此，浮点数相关的知识就介绍差不多了。为了让大家对整体再有一个更好的掌握，对浮点数的分类进行一些总结。

从上面的讲解，IEEE754 浮点数，指数是关键，根据指数，将其分为：特殊值、非规范化浮点数和规范化浮点数。

从上图规范化和非规范化浮点数的表示范围可以看出，两种类型的表示是具有连续性的。这也就是为什么非规范化浮点数指数规定为比规范形式的偏移值小 1（即单精度为 -126，双精度为 -2046）。

在数轴上，浮点数的分布：

10、总结

《深入理解计算机系统》这本书在讲解浮点数时说：许多程序员认为浮点数没意思，往坏了说，深奥难懂。经过本文的四千多字图文并茂的方式讲解，如果你认真看完了，我相信你一定掌握了浮点数。

此外，还有其他一些知识点，比如浮点数的运算、不满足结合律、四舍但五不一定入等，有兴趣的可以查阅相关资料。

现在是时候回过头来看看开始的题目了，你都会了吗？

最后，建议你结合你熟悉的语言更进一步补充相关知识。比如 Go 语言的 math 标准库；Java 的 java.lang.Float/Double 等包。

参考资料或相关链接

https://floating-point-gui.de/https://www.geeksforgeeks.org/ieee-standard-754-floating-point-numbers/https://baseconvert.com/这个交互式工具，很不错：http://evanw.github.io/float-toy/https://bartaz.github.io/ieee754-visualization/柴大：https://mp.weixin.qq.com/s/0lCte3UD5qYcaBnebwnYrQ左神：https://mp.weixin.qq.com/s/QsEe34pcimNdqCb99h44cQ图书《程序是怎样跑起来的》