Convertir flotador a doble sin perder precisión

Encuentro la conversión a la representación binaria más fácil de entender este problema.

float f = 0.27f;
double d2 = (double) f;
double d3 = 0.27d;

System.out.println(Integer.toBinaryString(Float.floatToRawIntBits(f)));
System.out.println(Long.toBinaryString(Double.doubleToRawLongBits(d2)));
System.out.println(Long.toBinaryString(Double.doubleToRawLongBits(d3)));

Puede ver que el flotador se expande al doble agregando 0s al final, pero que la doble representación de 0.27 es 'más precisa', de ahí el problema.

   111110100010100011110101110001
11111111010001010001111010111000100000000000000000000000000000
11111111010001010001111010111000010100011110101110000101001000

Esto se debe al contrato de Float.toString(float), que dice en parte:

Para cuántos dígitos se deben imprimir la parte fraccionaria [...]? Alli debe tener al menos un dígito para representar la parte fraccionaria, y más allá de eso, como muchos, pero solo como muchos, más dígitos que se necesitan para distinguir el valor del argumento de valores adyacentes de tipo float. Que es, supongamos que x es el exacto valor matemático representado por el decimal representación producida por este método para un distinto de cero finito argumento f. Entonces f debe ser el flotador valor más cercano a x; o, si dos flotadores los valores son igualmente cercanos a x, luego f debe ser uno de ellos y el menos parte significativa de la significand de f debe ser 0.

Me he encontrado con este problema hoy y no pude usar refactor a BigDecimal, porque el proyecto es realmente enorme. Sin embargo, encontré solución usando

Float result = new Float(5623.23)
Double doubleResult = new FloatingDecimal(result.floatValue()).doubleValue()

Y esto funciona.

Tenga en cuenta que llamar resultado.doubleValue () devuelve 5623.22998046875

Pero llamando a doubleResult.doubleValue () devuelve correctamente 5623.23

Pero no estoy del todo seguro si es una solución correcta.

Utilice un BigDecimal en lugar de float/double. Hay muchos números que no se pueden representar como punto flotante binario (por ejemplo, 0.1). Por lo tanto, siempre debe redondear el resultado a una precisión conocida o usar BigDecimal.

Véase http://en.wikipedia.org/wiki/Floating_point para más información.

Encontré la siguiente solución:

public static Double getFloatAsDouble(Float fValue) {
    return Double.valueOf(fValue.toString());
}

Si se uso float y doble en lugar de Float y Doble utilice el siguiente:

public static double getFloatAsDouble(float value) {
    return Double.valueOf(Float.valueOf(value).toString()).doubleValue();
}

Los flotadores, por naturaleza, son imprecisos y siempre tienen "problemas"de redondeo. Si la precisión es importante, entonces podría considerar refactorizar su aplicación para usar Decimal o BigDecimal.

Sí, los flotadores son computacionalmente más rápidos que los decimales debido al soporte on processor. Sin embargo, ¿quieres rápido o preciso?

Para información, esto viene bajo el Ítem 48 - Evitar float y double cuando se requieren valores exactos, de Effective Java 2nd edition por Joshua Bloch. Este libro está repleto de cosas buenas y definitivamente vale la pena echarle un vistazo.

¿Funciona esto?

float flt = 145.664454;

Double dbl = 0.0;
dbl += flt;

Si necesitas hacerlo con envoltorios:

Double d = new Float(123f).doubleValue();