# Convert float to double without losing precision

I have a primitive float and I need as a primitive double. Simply casting the float to double gives me weird extra precision. For example:

``````float temp = 14009.35F;
System.out.println(Float.toString(temp)); // Prints 14009.35
System.out.println(Double.toString((double)temp)); // Prints 14009.349609375
``````

However, if instead of casting, I output the float as a string, and parse the string as a double, I get what I want:

``````System.out.println(Double.toString(Double.parseDouble(Float.toString(temp))));
// Prints 14009.35
``````

Is there a better way than to go to String and back?

It's not that you're actually getting extra precision - it's that the float didn't accurately represent the number you were aiming for originally. The double is representing the original float accurately; `toString` is showing the "extra" data which was already present.

For example (and these numbers aren't right, I'm just making things up) suppose you had:

``````float f = 0.1F;
double d = f;
``````

Then the value of `f` might be exactly 0.100000234523. `d` will have exactly the same value, but when you convert it to a string it will "trust" that it's accurate to a higher precision, so won't round off as early, and you'll see the "extra digits" which were already there, but hidden from you.

When you convert to a string and back, you're ending up with a double value which is closer to the string value than the original float was - but that's only good if you really believe that the string value is what you really wanted.

Are you sure that float/double are the appropriate types to use here instead of `BigDecimal`? If you're trying to use numbers which have precise decimal values (e.g. money), then `BigDecimal` is a more appropriate type IMO.