parseFloat（）与parseDouble（）

Question

I am trying the code below to convert string to float and double but getting different results.

Code:

 System.out.println(Float.parseFloat("120059389"));
 System.out.println(Double.parseDouble("120059389"));

Output:

1.20059392E8
1.20059389E8

Could somebody explain me why I got different result for parsing string in float and double? What are the ranges for float and double?

Answer 1

This is because you're trying to parse a float by giving it more digits of precision than it can handle. The "ulp" (unit in last place) of a float that big is 8.0 , but the "ulp" for a double that big is still reasonably small. That is, at that magnitude, the closest possible float values differ by 8 , but the closest double values, with more precision, differ by far less.

System.out.println(Math.ulp(120059389f));
System.out.println(Math.ulp(120059389d));

This prints:

8.0
1.4901161193847656E-8

So the Float parser must use the closest float to the true value of 120059389 , which happens to be 1.20059392E8 .

Answer 2

The difference lies in the fact that Double and Float store numbers differently.

With Single and Double precision, allowing Double to give Double the amount of precision the Float can handle.

So the simple answer is that because of Float 's limited memory in comparison to Double information is lost upon conversion of numbers out of the range Float can handle.

• Float : 32-bit Numbers
• Double : 64-bit Numbers

So in the conversion some information is lost when converting to the Float because it is truncated.

Generally...

Float stores numbers as 1 bit for the sign ( -/+ ), 8 bits for the Exponent, and 23 bits for the fraction.

Double stores numbers as 1 bit for the sign ( -/+ ), 8 bits for the Exponent, and 53 bits for the fraction.

When you convert your number 120059389 = 111001001111111010111111101b has 27 bits worth of information which can be covered by the Double 's 53 bit allowence, but not by the Float 's 23 bit allowance, and the data is truncated at the least significant end.

The conversion will round the number to the nearest representable number using 23 bits 1.20059392 = 111001001111111011000000000b and the exponent will handle the rest of the expansion.

Answer 3

The earlier links and answers give good technical answers. The 'laymans' answer is that a float is 32 bits and a double is 64 bits. Some of those bits are used for the number and some are used for the exponent. The number you put in your code simply had too many digits for the 32 bit 'float'. The 64 bit 'double' has more bits and can be more precise with larger numbers.

The same concept holds for even larger numbers when you reach the limits of a 64 bit double and need 128 bits of precision.