Unexpected behavior of double primitive type data
I want to understand how the Java double type will store its value in memory in Java. When I run the following code I get unexpected output:
public static void main(String[] args) {
float a = 1.5f;
float b= 0.5f;
double c= 1.5;
double d = 0.5;
float a1 = 1.4f;
float b1= 0.5f;
double c1= 1.4;
double d1 = 0.5;
System.out.println(" a- b is " + (a-b));
System.out.println(" c- d is " + (c-d));
System.out.println("a1-b1 is " + (a1-b1));
System.out.println("c1-d1 is " + (c1-d1));
}
Output:
a- b is 1.0 c- d is 1.0 a1-b1 is 0.9 c1-d1 is 0.8999999999999999
Why is c1-d1 not equal to 0.9 ?
I also tried other different values but some time it return expected result and some time not.
While you might have heard about rounding errors, you might be wondering why you have a rounding error here.
float a1 = 1.4f;
float b1 = 0.5f;
double c1 = 1.4;
double d1 = 0.5;
System.out.println(new BigDecimal(a1) + " - " + new BigDecimal(b1) + " is " +
new BigDecimal(a1).subtract(new BigDecimal(b1)) + " or as a float is " + (a1 - b1));
System.out.println(new BigDecimal(c1) + " - " + new BigDecimal(d1) + " is " +
new BigDecimal(c1).subtract(new BigDecimal(d1)) + " or as a double is " + (c1 - d1));
prints
1.39999997615814208984375 - 0.5 is 0.89999997615814208984375 or as a float is 0.9
1.399999999999999911182158029987476766109466552734375 - 0.5 is
0.899999999999999911182158029987476766109466552734375
or as a double is 0.8999999999999999
As you can see, neither float nor double can represent these values exactly, and when the float or double is printed, some rounding occurs to hide this from you. In this case of float, the rounding to 7 decimal places yields the number you expected. In the case of double which has 16 digits of precision, the rounding error is visible.
As @Eric Postpischil, notes whether the float or double operation has a rounding error depends entirely on the values used. In this situation, it was the float which appeared to be more accurate even through the represented value was further from 0.9 than the double value.
In short: if you are going to use float or double you should use a sensible rounding strategy. If you can't do this, use BigDecimal.
System.out.printf("a1 - b1 is %.2f%n", (a1 - b1));
System.out.printf("c1 - d1 is %.2f%n", (c1 - d1));
prints
a1 - b1 is 0.90
c1 - d1 is 0.90
When you print a float or double, it assumes that the nearest short decimal value is the one you really want. ie within 0.5 ulp.
Eg
double d = 1.4 - 0.5;
float f = d;
System.out.println("d = " + d + " f = " + f);
prints
d = 0.8999999999999999 f = 0.9
Java documentation for println refers (through several links) to the documentation for toString . The documentation for toString says that the number of digits printed for float or double is the number needed to uniquely distinguish the value from adjacent representable values in the same type.
When “1.4f” is converted to float, the result is 1.39999997615814208984375 (in hexadecimal floating point, 0x1.666666p+0). When .5 is subtracted, the result is 0.89999997615814208984375 (0x1.ccccccp-1). As it happens, this float is also the float that is closest to .9. So, when it is printed, “.9” is printed.
When “1.4” is converted to double, the result is 1.399999999999999911182158029987476766109466552734375 (0x1.6666666666666p+0). When .5 is subtracted, the result is 0.899999999999999911182158029987476766109466552734375 (0x1.cccccccccccccp-1). This is not the double that is closest to .9, as 0.90000000000000002220446049250313080847263336181640625 (0x1.ccccccccccccdp-1) is closer. Therefore, when it is printed, the Java specification requires that the value be printed more finely, distinguishing it from .9. The result, “0.8999999999999999”, accurately represents the actual value.
链接地址: http://www.djcxy.com/p/65238.html下一篇: 双原始类型数据的意外行为