Convertissez float en double sans perdre de précision

J'ai un flotteur primitif et j'en ai besoin comme double primitif. Le simple fait de lancer le flotteur pour doubler me donne une précision supplémentaire étrange. Par exemple:

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

Cependant, si au lieu de lancer un cast, je produis le float sous forme de chaîne et analyse la chaîne comme un double, j'obtiens ce que je veux:

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

Y a-t-il un meilleur moyen que d'aller à String et revenir?

Ce n'est pas que vous réellement obtenir une précision supplémentaire - c'est que le flotteur ne représente pas exactement le nombre que vous visiez à l' origine. Le double est représentant le flotteur d' origine avec précision; toStringaffiche les données «supplémentaires» déjà présentes.

Par exemple (et ces chiffres ne sont pas corrects, je ne fais qu'inventer) supposons que vous aviez:

float f = 0.1F;
double d = f;

La valeur de fpourrait alors être exactement 0,100000234523. daura exactement la même valeur, mais lorsque vous la convertissez en une chaîne, elle «fera confiance» à sa précision avec une précision plus élevée, donc ne sera pas arrondie aussi tôt, et vous verrez les «chiffres supplémentaires» qui étaient déjà là, mais caché de vous.

Lorsque vous convertissez en chaîne et inversement, vous vous retrouvez avec une valeur double qui est plus proche de la valeur de la chaîne que ne l'était le flottant d'origine - mais ce n'est bon que si vous pensez vraiment que la valeur de chaîne est ce que vous vouliez vraiment.

Êtes-vous sûr que float / double sont les types appropriés à utiliser ici au lieu de BigDecimal? Si vous essayez d'utiliser des nombres qui ont des valeurs décimales précises (par exemple de l'argent), alors BigDecimalest un type IMO plus approprié.

Je trouve que la conversion à la représentation binaire est plus facile à saisir ce problème.

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)));

Vous pouvez voir que le flottant est étendu au double en ajoutant des 0 à la fin, mais que la double représentation de 0,27 est «plus précise», d'où le problème.

   111110100010100011110101110001
11111111010001010001111010111000100000000000000000000000000000
11111111010001010001111010111000010100011110101110000101001000

Cela est dû au contrat de Float.toString(float), qui dit en partie:

Combien de chiffres doivent être imprimés pour la partie fractionnaire […]? Il doit y avoir au moins un chiffre pour représenter la partie fractionnaire, et au-delà autant, mais seulement autant, plus de chiffres que nécessaire pour distinguer de manière unique la valeur d'argument des valeurs adjacentes de type float. Autrement dit, supposons que x soit la valeur mathématique exacte représentée par la représentation décimale produite par cette méthode pour un argument fini non nul f. Alors f doit être la valeur flottante la plus proche de x; ou, si deux valeurs flottantes sont également proches de x, alors f doit être l'une d'entre elles et le bit le moins significatif du significande de f doit être 0.

J'ai rencontré ce problème aujourd'hui et je n'ai pas pu utiliser refactor vers BigDecimal, car le projet est vraiment énorme. Cependant, j'ai trouvé une solution en utilisant

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

Et cela fonctionne.

Notez que l'appel de result.doubleValue () renvoie 5623.22998046875

Mais appeler doubleResult.doubleValue () renvoie correctement 5623.23

Mais je ne suis pas tout à fait sûr que ce soit une solution correcte.

J'ai trouvé la solution suivante:

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

Si vous utilisez float et double au lieu de Float et Double, utilisez ce qui suit:

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

Utilisez un BigDecimalau lieu de float/ double. Il y a beaucoup de nombres qui ne peuvent pas être représentés en virgule flottante binaire (par exemple, 0.1). Vous devez donc toujours arrondir le résultat à une précision ou à une utilisation connue BigDecimal.

Voir http://en.wikipedia.org/wiki/Floating_point pour plus d'informations.

Les flotteurs, par nature, sont imprécis et ont toujours des «problèmes» d'arrondi soignés. Si la précision est importante, vous pouvez envisager de refactoriser votre application pour utiliser Decimal ou BigDecimal.

Oui, les flottants sont plus rapides que les nombres décimaux en raison de la prise en charge du processeur. Cependant, voulez-vous rapide ou précis?

Pour information, ceci relève de l'article 48 - Évitez les flottants et doublez lorsque des valeurs exactes sont requises, de Effective Java 2nd edition par Joshua Bloch. Ce livre regorge de bonnes choses et vaut vraiment le détour.

Est-ce que ça marche?

float flt = 145.664454;

Double dbl = 0.0;
dbl += flt;

Une solution simple qui fonctionne bien consiste à analyser le double à partir de la représentation sous forme de chaîne du float:

double val = Double.valueOf(String.valueOf(yourFloat));

Pas super efficace, mais ça marche!