Comment imprimer une valeur double sans notation scientifique en utilisant Java ?

Question

Je veux imprimer une valeur double en Java sans forme exponentielle.

double dexp = 12345678;
System.out.println("dexp: "+dexp);

Il montre cette notation E : 1.2345678E7 .

Je veux qu'il l'imprime comme ça : 12345678

Quelle est la meilleure façon d'éviter cela ?

Answer 1

Java empêche la notation E dans un double :

Cinq façons différentes de convertir un double en un nombre normal :

import java.math.BigDecimal;
import java.text.DecimalFormat;

public class Runner {
    public static void main(String[] args) {
        double myvalue = 0.00000021d;

        //Option 1 Print bare double.
        System.out.println(myvalue);

        //Option2, use decimalFormat.
        DecimalFormat df = new DecimalFormat("#");
        df.setMaximumFractionDigits(8);
        System.out.println(df.format(myvalue));

        //Option 3, use printf.
        System.out.printf("%.9f", myvalue);
        System.out.println();

        //Option 4, convert toBigDecimal and ask for toPlainString().
        System.out.print(new BigDecimal(myvalue).toPlainString());
        System.out.println();

        //Option 5, String.format 
        System.out.println(String.format("%.12f", myvalue));
    }
}

Ce programme imprime :

2.1E-7
.00000021
0.000000210
0.000000210000000000000001085015324114868562332958390470594167709350585
0.000000210000

Qui ont tous la même valeur.

Protip : Si vous ne comprenez pas pourquoi ces chiffres aléatoires apparaissent au-delà d'un certain seuil dans la valeur double, cette vidéo l'explique : computerphile why does 0.1 + 0.2 égal 0.30000000000001 ?

http://youtube.com/watch?v=PZRI1IfStY0

Answer 2

Vous pourriez utiliser printf() con %f :

double dexp = 12345678;
System.out.printf("dexp: %f\n", dexp);

Ceci imprimera dexp: 12345678.000000 . Si vous ne voulez pas la partie fractionnaire, utilisez

System.out.printf("dexp: %.0f\n", dexp);

0 en %.0f signifie 0 place dans la partie fractionnaire, c'est-à-dire aucune partie fractionnaire. Si vous voulez imprimer la partie fractionnaire avec le nombre de décimales désiré, au lieu de 0, fournissez simplement le nombre comme ceci %.8f . Par défaut, la partie fractionnaire est imprimée jusqu'à 6 décimales.

Cette opération utilise le langage des spécificateurs de format expliqué dans le document documentation .

La valeur par défaut toString() utilisé dans votre code d'origine est expliqué en toutes lettres aquí .

Answer 3

En bref :

Si vous voulez vous débarrasser des zéros de fin et des problèmes de Locale, vous devez utiliser :

double myValue = 0.00000021d;

DecimalFormat df = new DecimalFormat("0", DecimalFormatSymbols.getInstance(Locale.ENGLISH));
df.setMaximumFractionDigits(340); // 340 = DecimalFormat.DOUBLE_FRACTION_DIGITS

System.out.println(df.format(myValue)); // Output: 0.00000021

Explication :

Les autres réponses ne me convenaient pas :

• Double.toString() o System.out.println o FloatingDecimal.toJavaFormatString utilise les notations scientifiques si le double est inférieur à 10^-3 ou supérieur ou égal à 10^7

• En utilisant %f La précision décimale par défaut est de 6, sinon vous pouvez la coder en dur, mais cela entraîne l'ajout de zéros supplémentaires si vous avez moins de décimales. Exemple :

  double myValue = 0.00000021d;
  String.format("%.12f", myvalue); // Output: 0.000000210000

• En utilisant setMaximumFractionDigits(0); o %.0f vous supprimez toute précision décimale, ce qui est bien pour les entiers/longs, mais pas pour les doubles :

  double myValue = 0.00000021d;
  System.out.println(String.format("%.0f", myvalue)); // Output: 0
  DecimalFormat df = new DecimalFormat("0");
  System.out.println(df.format(myValue)); // Output: 0

• En utilisant DecimalFormat, vous êtes dépendant du local. En français, le séparateur décimal est une virgule, pas un point :

  double myValue = 0.00000021d;
  DecimalFormat df = new DecimalFormat("0");
  df.setMaximumFractionDigits(340);
  System.out.println(df.format(myvalue)); // Output: 0,00000021

  L'utilisation de la locale ENGLISH garantit l'obtention d'un séparateur de points pour les décimales, quel que soit le lieu d'exécution de votre programme.

Pourquoi utiliser 340 alors pour setMaximumFractionDigits ?

Pour deux raisons :

• setMaximumFractionDigits accepte un nombre entier, mais son implémentation a un nombre maximum de chiffres autorisés de DecimalFormat.DOUBLE_FRACTION_DIGITS qui est égal à 340
• Double.MIN_VALUE = 4.9E-324 Ainsi, avec 340 chiffres, vous êtes sûr de ne pas arrondir votre double et de perdre en précision.

Answer 4

Vous pouvez l'essayer avec DecimalFormat . Avec cette classe, vous disposez d'une grande souplesse dans l'analyse de vos chiffres.
Vous pouvez définir exactement le modèle que vous souhaitez utiliser.
Dans votre cas par exemple :

double test = 12345678;
DecimalFormat df = new DecimalFormat("#");
df.setMaximumFractionDigits(0);
System.out.println(df.format(test)); //12345678

Answer 5

Cela fonctionne tant que votre nombre est un nombre entier :

double dnexp = 12345678;
System.out.println("dexp: " + (long)dexp);

Si la variable double a une précision après la virgule, elle sera tronquée.