# Java中浮点类型的精度问题 double float

## IEEE 754 标准

IEEE 754 标准是IEEE二进位浮点数算术标准(Standard for Floating-Point Arithmetic)的标准编号，等同于国际标准ISO/IEC/IEEE 60559  。该标准由美国电气电子工程师学会(IEEE)计算机学会旗下的微处理器标准委员会(Microprocessor Standards Committee, MSC)发布。

IEEE 754 标准规定了计算机程序设计环境中的二进制和十进制的浮点数自述的交换、算术格式以及方法
IEEE 754 标准是最广泛使用的浮点数运算标准，为许多CPU与浮点运算器所采用。
IEEE 754 标准规定了四种表示浮点数值的方式：单精确度(32位)、双精确度(64位)、延伸单精确度(43位以上，很少使用)与延伸双精确度(79位元以上，通常以80位元实做)。只有32位模式有强制要求，其他都是选择性的。

## 官方文档中的介绍

Floating-Point Types, Formats, and Values

The floating-point types are float and double, which are conceptually概念 associated with the single-precision 32-bit and double-precision 64-bit format IEEE 754 values and operations as specified指定 in IEEE Standard for Binary Floating-Point Arithmetic, ANSI/IEEE Standard 754-1985 (IEEE, New York).

The IEEE 754 standard includes not only positive and negative numbers that consist of a sign and magnitude量级, but also positive and negative zeros, positive and negative infinities, and special Not-a-Number values (hereafter今后 abbreviated缩写 NaN). A NaN value is used to represent the result of certain某些 invalid operations such as dividing zero by zero. NaN constants of both float and double type are predefined as Float.NaN and Double.NaN.

IEEE 754标准不仅包括正数和负数，它们包括符号和量级，还包括正和负零，正负无穷大和特殊非数字值（以下简称为NaN）。NaN值用于表示某些无效操作的结果，例如将零除零。floatdouble类型的NaN常数预定义为Float.NaN Double.NaN

Every implementation of the Java programming language is required to support two standard sets of floating-point values, called the float value set and the double value set. In addition, an implementation of the Java programming language may support either or both of two extended-exponent扩展指数 floating-point value sets, called the float-extended-exponent value set and the double-extended-exponent value set. These extended-exponent value sets may, under certain circumstances, be used instead of the standard value sets to represent the values of expressions of type float or double (§5.1.13, §15.4).

Java编程语言的每个实现都需要支持两个标准的浮点值集合，称为float value set 和 double value set此外，Java编程语言的实现可以支持称为float扩展指数值集合double扩展指数值集合的两个扩展指数浮点值集合中的一个或两者在某些情况下，这些扩展指数值集可以用来代替标准值集合来表示类型floatdouble§5.1.13 §15.4表达式的值

The finite有限的 nonzero values of any floating-point value set can all be expressed in the form s · m · 2(e - N + 1), where s is +1 or -1, m is a positive integer less than 2N, and e is an integer between Emin = -(2K-1-2) and Emax = 2K-1-1, inclusive包含, and where N and K are parameters that depend on the value set. Some values can be represented in this form in more than one way; for example, supposing that a value v in a value set might be represented in this form using certain values for s, m, and e, then if it happened that m were even and e were less than 2K-1, one could halve m and increase e by 1 to produce a second representation for the same value v. A representation in this form is called normalized if m ≥ 2N-1; otherwise the representation is said to be denormalized. If a value in a value set cannot be represented in such a way that m ≥ 2N-1, then the value is said to be adenormalized value, because it has no normalized representation.

The constraints on the parameters N and K (and on the derived parameters Emin and Emax) for the two required and two optional floating-point value sets are summarized in Table 4.1.

Table 4.1. Floating-point value set parameters

Parameterfloatfloat-extended-exponentdoubledouble-extended-exponent
N24245353
K8≥ 1111≥ 15
Emax+127≥ +1023+1023≥ +16383
Emin-126≤ -1022-1022≤ -16382
...

## 浮点数的组成结构

• 符号位(S)：最高位(31位)为符号位，表示整个浮点数的正负，0为正，1为负
• 指数位(E)：23-30位共8位为指数位，这里指数的底数规定为2。并且指数位是以补码的形式来划分的(最高位为指数位的符号位，0为正，1为负)。另外，标准中还规定了，当指数位8位全0或全1的时候，浮点数为非正规形式，所以指数位真正范围为：-126~127。
• 尾数位(M)：0-22位共23位为尾数位，表示小数部分的尾数，即形式为1.M或0.M，至于什么时候是 1 什么时候是 0，则由指数和尾数共同决定。小数部分最高有效位是1的数被称为正规(规格化)形式。小数部分最高有效位是0的数被称为非正规(非规格化)形式，其他情况是特殊值。

## 取值范围

float和double的【取值范围】是由【指数的位数】来决定的，中，负指数决定了浮点数所能表达的【绝对值最小】的非0数，而正指数决定了浮点数所能表达的【绝对值最大】的数，也即决定了浮点数的取值范围。
S：符号位，E：指数位，M：尾数位
float：S1_E8_M23，指数位有8位，指数的取值范围为-2^7~2^7-1(即-128~127)
float的取值范围为-2^128 ~ +2^127(10^38级别的数)
double：S1_E11_M52，指数位有11位，指取的取值数范围为-2^10~2^10-1(即-1024~1023)
double的取值范围为-2^1024 ~ +2^1023(10^308级别的数)

PS：官方文档中好像说float指数的取值范围为-126~127，double指取的取值数范围为-1022~1023

## 精度

float和double的【精度】是由【尾数的位数】来决定的，float的尾数位有23位，double的尾数位有52位。
float：S1_E8_M23，尾数位有23位，2^23 = 83886_08，一共7位，这意味着最多能有7位有效数字，但能保证的为6位，也即float的精度为6~7位有效数字；
double：S1_E11_M52，尾数位有52位，2^52 = 45035_99627_37049_6，一共16位，同理，double的精度为15~16位有效数字。

## 总结

float      32bit单精度   1bit(0正1负)   8bit          -2^7~2^7-1(-128~127)             2^127(10^38级别的数)       23bit        8388608,7位,精度为6~7位
double  64bit双精度   1bit(0正1负)   11bits      -2^10~2^10-1(-1024~1023)     2^1023(10^308级别的数)    52bit       45035_99627_37049_6,16位,精度为15~16位

## 十进制浮点数如何用二进制表示

计算过程：将该数字乘以2，取出整数部分作为二进制表示的第1位(大于等于1为1，小于1为0)；然后再将小数部分乘以2，将得到的整数部分作为二进制表示的第2位......以此类推，直到小数部分为0。

0.6 * 2 = 1.2 ——————- 1
0.2 * 2 = 0.4 ——————- 0
0.4 * 2 = 0.8 ——————- 0
0.8 * 2 = 1.6 ——————- 1

0.6 * 2 = 1.2 ——————- 1
0.2 * 2 = 0.4 ——————- 0
…………

## 二进制浮点数如何转换为十进制

计算过程：从左到右，v[i] * 2^( - i ), i 为从左到右的index，v[i]为该位的值，直接看例子，很直接的

1 * 2^-1 + 0 * 2^-2 + 0 * 2^-3 + 1 * 2^-4 + 1 * 2^-5 + ……
= 1 * 0.5 + 0 + 0 + 1 * 1/16 + 1 * 1/32 + ……
= 0.5 + 0.0625 + 0.03125 + ……
=无限接近0.6

## 为何float类型的值赋给double类型的变量后可能会出现精度问题

float类型的变量f=0.6f：    1001 1001 1001 1001 1001 100
double类型的d1=0.6d：   1001 1001 1001 1001 1001 1001 1001 1001 1001 1001 1001 1001 1001
float类型的变量 f 赋值给double类型的变量 d2 后，d2 中实际中的数据为：
1001 1001 1001 1001 1001 1000 0000 0000 0000 0000 0000 0000 0000

float f = 0.6f;
double d1 = 0.6d;
double d2 = f;
System.out.println((d1 == d2) + "  " + f + "    " + d2);//false  0.6    0.6000000238418579
double d = 0.6;
System.out.println((float) d + "    " + d);//0.6    0.6

## 浮点数参与运算示例代码

//注意，以下案例是刻意挑选出来的，并【不是所有】情况都会出现类似问题的
System.out.println(0.05+0.01);          //0.060000000000000005
System.out.println(1.0-0.42);           //0.5800000000000001
System.out.println(4.015*100);          //401.49999999999994
System.out.println(123.3/100);          //1.2329999999999999

double addValue = BigDecimal.valueOf(0.05).add(BigDecimal.valueOf(0.01)).doubleValue();
System.out.println("0.05+0.01=" + (0.05 + 0.01) + "  " + addValue);//0.05+0.01=0.060000000000000005  0.06

double subtractValue = BigDecimal.valueOf(1.0).subtract(BigDecimal.valueOf(0.42)).doubleValue();
System.out.println("1.0-0.42=" + (1.0 - 0.42) + "  " + subtractValue);//1.0-0.42=0.5800000000000001  0.58

double multiplyValue = BigDecimal.valueOf(4.015).multiply(BigDecimal.valueOf(100)).doubleValue();
System.out.println("4.015*100=" + (4.015 * 100) + "  " + multiplyValue);//4.015*100=401.49999999999994  401.5

double divideValue = BigDecimal.valueOf(123.3).divide(BigDecimal.valueOf(100), 10, BigDecimal.ROUND_HALF_UP).doubleValue();
System.out.println("123.3/100=" + (123.3 / 100) + "  " + divideValue);//123.3/100=1.2329999999999999  1.233

String pattern = "#,##0.00";//强制保留两位小数，整数部分每三位以逗号分隔，整数部分至少一位
DecimalFormat format = new DecimalFormat(pattern);
format.setRoundingMode(RoundingMode.HALF_UP);//默认不是四舍五入，而是HALF_EVEN
System.out.println(format.format(0.05 + 0.01)); //0.06
System.out.println(format.format(1.0 - 0.42)); //0.58
System.out.println(format.format(4.015 * 100)); // 401.50
System.out.println(format.format(123.3 / 100)); //1.23

double d = 0.06;//Java当中默认声明的小数是double类型的，其默认后缀"d"或"D"可以省略
float f = 0.06f;//如果要声明为float类型，需显示添加后缀"f"或"F"
System.out.println((0.05 + 0.01) + "  " + (0.05f + 0.01f));//0.060000000000000005  0.060000002
System.out.println((d == (0.05 + 0.01)) + "  " + (f == (0.05f + 0.01f)));//false  false

System.out.println(d + "  " + f + "  " + (float) d + "  " + (double) f);//0.06  0.06  0.06  0.05999999865889549
System.out.println((d == f) + "  " + (d == (double) f) + "  " + ((float) d == f));//false  false  true
//虽然向下转型后可以保证相等，但是一般不会主动干丢失精度的事的！
2017-8-29

posted @ 2017-08-29 17:00  白乾涛  阅读(...)  评论(...编辑  收藏