Comment puis-je imprimer un double de la valeur sans la notation scientifique à l'aide de Java?

Vous pouvez utiliser printf() avec %f:

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

Cette impression sera dexp: 12345678.000000. Si vous ne voulez pas de la partie fractionnaire, utilisez

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

Il utilise le spécificateur de format langue expliqué dans le la documentation.

La valeur par défaut toString() format utilisé dans votre code original est écrit ici.

En bref:

Si vous voulez vous débarrasser de zéros et les paramètres Régionaux des problèmes, alors vous devriez 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:

Pourquoi les autres réponses ne me convient pas:

• Double.toString() ou System.out.println ou FloatingDecimal.toJavaFormatString utilise scientifique notations si un double est inférieur à 10^-3 ou supérieure ou égale à 10^7

• En utilisant %f, la valeur par défaut, la précision décimale est de 6, sinon, vous pouvez coder en dur, mais il en résulte supplémentaire ajouter des zéros si vous avez moins de décimales. Exemple:

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

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

  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 locales dépendantes. Dans les paramètres régionaux 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

  En utilisant les paramètres régionaux ANGLAIS vous permet d'obtenir un point pour le séparateur décimal, où que votre programme s'exécute.

Pourquoi à l'aide de 340 puis pour setMaximumFractionDigits?

Deux raisons:

• setMaximumFractionDigits accepte un entier, mais sa mise en œuvre a un maximum de chiffres permis de DecimalFormat.DOUBLE_FRACTION_DIGITS ce qui équivaut à 340
• Double.MIN_VALUE = 4.9E-324 donc, avec 340 chiffres, vous êtes sûr de ne pas faire le tour de votre double et une perte de précision.

J'en ai une autre solution impliquant BigDecimal de toPlainString(), mais cette fois à l'aide de la Chaîne-constructeur, ce qui est recommandé dans la javadoc:

ce constructeur est compatible avec les valeurs retournées par Flotteur.toString et Double.toString. Ce est généralement la meilleure façon de convertir un float ou double dans un BigDecimal, car il ne souffre pas de l'imprévisibilité de la BigDecimal(double) constructeur.

Il ressemble dans sa forme la plus courte:

return new BigDecimal(myDouble.toString()).stripTrailingZeros().toPlainString();

Avant Java 8, il en résulte "0.0" pour toute valeur zéro est doublé, de sorte que vous devez ajouter:

if (myDouble.doubleValue() == 0)
    return "0";

NaN et infini de valeurs doivent être vérifiés supplémentaire.

Le résultat final de toutes ces considérations:

public static String doubleToString(Double d) {
    if (d == null)
        return null;
    if (d.isNaN() || d.isInfinite())
        return d.toString();

    //Pre Java 8, a value of 0 would yield "0.0" below
    if (d.doubleValue() == 0)
        return "0";
    return new BigDecimal(d.toString()).stripTrailingZeros().toPlainString();
}

Cela peut aussi être copié/collé de travailler bien avec Flotteur.

J'avais besoin de convertir une sorte de double de la valeur des devises et constaté que la plupart des solutions ont été OK, mais pas pour moi.

La DecimalFormat a finalement été le moyen pour moi, c'est ce que j'ai fait:

   public String foo(double value) //Got here 6.743240136E7 or something..
    {
        DecimalFormat formatter;

        if(value - (int)value > 0.0)
            formatter = new DecimalFormat("0.00"); //Here you can also deal with rounding if you wish..
        else
            formatter = new DecimalFormat("0");

        return formatter.format(value);
    }

Comme vous pouvez le voir, si le nombre est naturel je obtenir - dire - 20000000 au lieu de 2E7 (etc.) - sans point décimal.

Et si c'est décimal, je ne reçois que deux chiffres après la virgule.

Le code suivant détecte si le nombre est présenté en notation scientifique. Si donc il est représenté dans la présentation normale avec un maximum de " 25 de chiffres.

 static String convertFromScientificNotation(double number) {
    //Check if in scientific notation
    if (String.valueOf(number).toLowerCase().contains("e")) {
        System.out.println("The scientific notation number'"
                + number
                + "' detected, it will be converted to normal representation with 25 maximum fraction digits.");
        NumberFormat formatter = new DecimalFormat();
        formatter.setMaximumFractionDigits(25);
        return formatter.format(number);
    } else
        return String.valueOf(number);
}

J'ai eu ce même problème dans mon code quand je l'utilise comme une entrée de chaîne de maths.Eval() fonction qui prend une chaîne de caractères comme "x + 20 /50"

J'ai regardé des centaines d'articles... À la fin, je suis allé avec cela à cause de la vitesse. Et parce que la fonction Eval allait se reconvertir dans son propre format de nombre par la suite et en mathématiques.Eval() ne prend pas en charge la fuite d'E-07 que d'autres méthodes sont retournés, et rien de plus de 5 dp a trop de détails pour que ma demande de toute façon.

C'est maintenant utilisé dans la production de code pour une application qui a plus de 1000 utilisateurs...

double value = 0.0002111d;
String s = Double.toString(((int)(value * 100000.0d))/100000.0d); //Round to 5 dp

s display as:  0.00021

Ma solution:
String str = String.format ("%.0f", yourDouble);