Question

I have a Double which I created like this:

Double d = Double.parseDouble( "27.86753" ); // All the digits of this double value are 27.867530822753906

This particular double can also be represented by a float, so Java drops the rest of my digits. How can I force Java to give me the true double representation (all of the digits) of this value?

Answer 1

Oh, man, interesting. You want to learn exactly how double does it inaccurately.

I think new BigDecimal(double).toString() will give you all of the incorrect digits, since BigDecimal represents a number with a precisely specified precision.

EDIT: Ohhhhhhhh, I think I see what’s going on.

Let me try to explain it like this: Double.toString returns the least precise String such that Double.parseDouble will return exactly the same double — just enough digits to “uniquely identify” the exact IEEE 754 value, though the actual value may have more digits than are printed. Just because Double.toString isn’t giving you as many digits as you expect doesn’t mean that the actual IEEE 754 double-precision value is being rounded to that many digits. new BigDecimal(double).toString will return the exact IEEE-754 value being stored.

UPDATE:

What’s going on is that when it prints out 27.86753, it’s actually internally a more precise value than the digits you’re quoting as the correct answer, 27.867530822753906. That’s just because toString is designed to print out only as much as necessary to ensure that Double.parseDouble(Double.toString(value)) is a no-op.

I ran the following code:

public static void main(String[] args) {
  double dWithFloat = Double.parseDouble(Double.toString(Float.parseFloat("27.86753")));
  double dJustParsed = Double.parseDouble("27.86753");
  System.out.println(dWithFloat);
  System.out.println(dJustParsed);

  BigDecimal bigFromFloat = new BigDecimal(dWithFloat);
  BigDecimal bigJustParsed = new BigDecimal(dJustParsed);
  System.out.println(bigFromFloat); 
    // prints the exact value from the double,
    // doesn't round or truncate like Double.toString
  System.out.println(bigJustParsed);

}

and it printed out

27.867530822753906 // Double.toString(Double.parseDouble(Double.toString(Float.parseFloat("27.86753"))));
27.86753 // Double.toString(Double.parseDouble("27.86753")) is indeed a no-op
27.86753082275390625 // This is the _actual_ value from D.parseD(D.toString(F.parseF("27.86753")))
27.867529999999998580051396857015788555145263671875 // This is the actual value from D.parseD("27.86753")

And indeed, this second value is noticeably closer to 27.86753, by a margin of something like 0.0000008.