为什么从float转换为double会改变这个值？

问题描述 投票：14回答：9

我一直试图找出原因，但我不能。有谁能够帮我？

请看下面的例子。

float f = 125.32f;
System.out.println("value of f = " + f);
double d = (double) 125.32f; 
System.out.println("value of d = " + d);

这是输出：

value of f = 125.32
value of d = 125.31999969482422
java floating-point double precision ieee-754
9个回答
15
投票

当转换为float时，double的值不会改变。显示的数字存在差异，因为需要更多的数字来区分double值与其邻居，即required by the Java documentation。这是toString的文档，它是通过println的文档引用的（通过几个链接）。

125.32f的准确值是125.31999969482421875。两个相邻的float值为125.3199920654296875和125.32000732421875。观察125.32比任何一个邻居更接近125.31999969482421875。因此，通过显示“125.32”，Java已显示足够的数字，以便从十进制数字转换回float，再现传递给float的println的值。

两个相邻的double值125.31999969482421875是125.3199996948242045391452847979962825775146484375和125.3199996948242329608547152020037174224853515625。 观察到125.32更接近后一个邻居而不是原始值（125.31999969482421875）。因此，打印“125.32”不包含足以区分原始值的数字。 Java必须打印更多数字，以确保从显示的数字转换回double再现传递给double的println的值。

12
投票
  1. 当您将float转换为double时，不会丢失任何信息。每个float都可以完全表示为double。
  2. 另一方面，System.out.println打印的十进制表示都不是数字的确切值。精确的十进制表示可能需要最多约760个十进制数字。相反，System.out.println精确打印允许将十进制表示形式解析回原始float或double的十进制数字。还有更多的doubles，所以当打印一个时，System.out.println需要打印更多的数字才能使表示变得明确。
4
投票

从float到double的转换是一个扩大的转换，如specified by the JLS。扩展转换被定义为较小集合到其超集的内射映射。因此，在从float转换为double之后，所表示的数字不会改变。

有关更新问题的更多信息

在您的更新中，您添加了一个示例，该示例应该证明该数字已更改。但是，它只显示数字的字符串表示已更改，实际上它是由于通过转换为double获得的额外精度。请注意，您的第一个输出只是第二个输出的四舍五入。由Double.toString指定，

必须至少有一个数字来表示小数部分，并且除此之外必须有多个，但只有多少个，更多的数字才能唯一地将参数值与double类型的相邻值区分开来。

由于double类型中的相邻值比float更接近，因此需要更多数字来符合该规则。

3
投票

最接近125.32的32位IEEE-754浮点数实际上是125.31999969482421875。非常接近，但不完全（那是因为0.32重复二进制）。

当你把它转换为double时，它的值是125.31999969482421875，它将变成一个double（125.32在这一点上无处可寻，它应该真正结束的信息.32完全丢失）当然可以表示完全是一个双。当你打印那个双，打印例程认为它有比实际更多的有效数字（但当然它不知道），所以它打印到125.31999969482422，这是最小的十进制，舍入到那个精确的双（和该长度的所有小数，它是最接近的）。

1
投票

浮点数的精度问题实际上与语言无关，所以我将在我的解释中使用MATLAB。

您看到差异的原因是某些数字在固定位数中不能完全表示。以0.1为例：

>> format hex

>> double(0.1)
ans =
   3fb999999999999a

>> double(single(0.1))
ans =
   3fb99999a0000000

因此，当您将其作为双精度浮点数转换时，单精度中0.1近似值的误差会变大。如果直接以双精度开始，结果与其近似值不同。

>> double(single(0.1)) - double(0.1)
ans =
     1.490116113833651e-09
1
投票

正如已经解释的那样，所有浮点数都可以精确地表示为双精度，你问题的原因是System.out.println在显示float或double的值时会执行一些舍入，但是舍入方法在两种情况下都不相同。

要查看浮点数的确切值，可以使用BigDecimal：

float f = 125.32f;
System.out.println("value of f = " + new BigDecimal(f));
double d = (double) 125.32f;
System.out.println("value of d = " + new BigDecimal(d));

哪个输出：

value of f = 125.31999969482421875
value of d = 125.31999969482421875
0
投票

它不会在java中工作，因为在java中默认情况下它将实际值作为double，如果我们声明一个没有浮动表示的浮点值，如123.45f默认情况下它会将它作为double，它将导致错误，因为精度损失

0
投票

由于将数值转换为String，相应地为java.lang.Float#toString(float)和java.lang.Double#toString(double)的方法的契约，值的表示会发生变化，而实际值保持不变。在上述两种方法的Javadoc中都有一个共同的部分，它阐述了对值'String表示的要求：

必须至少有一个数字来表示小数部分，并且除此之外必须有多个，但只有多少个，更多的数字，以便唯一地区分参数值和相邻值

为了说明两种类型的值的重要部分的相似性，可以运行以下代码段：

package com.my.sandbox.numbers;

public class FloatToDoubleConversion {

    public static void main(String[] args) {
        float f = 125.32f;
        floatToBits(f);
        double d = (double) f;
        doubleToBits(d);
    }

    private static void floatToBits(float floatValue) {
        System.out.println();
        System.out.println("Float.");
        System.out.println("String representation of float: " + floatValue);
        int bits = Float.floatToIntBits(floatValue);
        int sign = bits >>> 31;
        int exponent = (bits >>> 23 & ((1 << 8) - 1)) - ((1 << 7) - 1);
        int mantissa = bits & ((1 << 23) - 1);
        System.out.println("Bytes: " + Long.toBinaryString(Float.floatToIntBits(floatValue)));
        System.out.println("Sign: " + Long.toBinaryString(sign));
        System.out.println("Exponent: " + Long.toBinaryString(exponent));
        System.out.println("Mantissa: " + Long.toBinaryString(mantissa));
        System.out.println("Back from parts: " + Float.intBitsToFloat((sign << 31) | (exponent + ((1 << 7) - 1)) << 23 | mantissa));
        System.out.println(10D);
    }

    private static void doubleToBits(double doubleValue) {
        System.out.println();
        System.out.println("Double.");
        System.out.println("String representation of double: " + doubleValue);
        long bits = Double.doubleToLongBits(doubleValue);
        long sign = bits >>> 63;
        long exponent = (bits >>> 52 & ((1 << 11) - 1)) - ((1 << 10) - 1);
        long mantissa = bits & ((1L << 52) - 1);
        System.out.println("Bytes: " + Long.toBinaryString(Double.doubleToLongBits(doubleValue)));
        System.out.println("Sign: " + Long.toBinaryString(sign));
        System.out.println("Exponent: " + Long.toBinaryString(exponent));
        System.out.println("Mantissa: " + Long.toBinaryString(mantissa));
        System.out.println("Back from parts: " + Double.longBitsToDouble((sign << 63) | (exponent + ((1 << 10) - 1)) << 52 | mantissa));
    }
}

在我的环境中，输出是：

Float.
String representation of float: 125.32
Bytes: 1000010111110101010001111010111
Sign: 0
Exponent: 110
Mantissa: 11110101010001111010111
Back from parts: 125.32

Double.
String representation of double: 125.31999969482422
Bytes: 100000001011111010101000111101011100000000000000000000000000000
Sign: 0
Exponent: 110
Mantissa: 1111010101000111101011100000000000000000000000000000
Back from parts: 125.31999969482422

通过这种方式，您可以看到值的符号，指数是相同的，而其尾数被扩展保留其重要部分（11110101010001111010111）完全相同。

浮点数部分的使用提取逻辑：1和2。

-1
投票

两者都是微软所称的“近似数字数据类型”。

有一个原因。一个浮点数具有7位数的精度和一个双15。但我已经看到它发生了很多次8.0 - 1.0 - 6.999999999。这是因为不能保证它们完全代表十进制数。

如果需要绝对，不变的精度，请使用小数或整数类型。

最新问题
© www.soinside.com 2019 - 2024. All rights reserved.