Quel est l'équivalent Java de spécificateur de format printf% g de C?

Question

J'ai essayé d'utiliser Formatter.format, mais qui semble laisser la mantisse sur le nombre avec 0 mantisse, alors que la version C ne fonctionne pas. Y at-il un équivalent de spécificateur de format C g% en Java, et si non, est-il un moyen de faire semblant? Mon intention est de préserver la mantisse exactement comme C est pour des raisons de compatibilité.

foo.c

#include <stdio.h>

int main (int argc, char const *argv[])
{
    printf("%g\n", 1.0);
    return 0;
}

Main.java

class Main {
        public static void main(String[] args) {
                System.out.printf("%g\n", 1.0);
        }
}

Console:

$ javac Main.java && java Main
1.00000
$ gcc foo.c && ./a.out
1

De même, avec 1,2 en entrée, la mantisse est plus dans la version de Java

$ javac Main.java && java Main
1.20000
$ gcc foo.c && ./a.out
1.2

Answer 1

Avez-vous essayé java.text.DecimalFormat classe ?

System.out.println(new DecimalFormat().format(1.0));

sorties:

1

alors:

System.out.println(new DecimalFormat().format(1.2));

sorties:

1.2

Answer 2

modifier : Ce code fait la partie décimale à disparaître si l'exposant est de 17 chiffres, à cause de ma mauvaise compréhension de la façon dont String.format formaté ces chiffres. Alors ne vous plaît ne pas utiliser ce code: P

Merci pour les commentaires, les gars. Je ne pouvais pas trouver un moyen de configurer DecimalFormat ou NumberFormat pour cloner exactement la fonctionnalité, mais il semble que cette méthode fonctionne (suivi d'un exemple):

String.format("%.17g", x).replaceFirst("\\.?0+(e|$)", "$1");

main.c

#include <stdio.h>

int main (int argc, char const *argv[])
{
    printf("%.*g\n", 17, -0.0);
    printf("%.*g\n", 17, 0.0);
    printf("%.*g\n", 17, 1.0);
    printf("%.*g\n", 17, 1.2);
    printf("%.*g\n", 17, 0.0000000123456789);
    printf("%.*g\n", 17, 1234567890000000.0);
    printf("%.*g\n", 17, 0.0000000123456789012345678);
    printf("%.*g\n", 17, 1234567890123456780000000.0);
    return 0;
}

Main.java

class Main {
        public static String formatDouble(double x) {
                return String.format("%.17g", x).replaceFirst("\\.?0+(e|$)", "$1");
        }

        public static void main(String[] args) {
                System.out.println(formatDouble(-0.0));
                System.out.println(formatDouble(0.0));
                System.out.println(formatDouble(1.0));
                System.out.println(formatDouble(1.2));
                System.out.println(formatDouble(0.0000000123456789));
                System.out.println(formatDouble(1234567890000000.0));
                System.out.println(formatDouble(0.0000000123456789012345678));
                System.out.println(formatDouble(1234567890123456780000000.0));
        }
}

et leurs sorties:

$ gcc foo.c && ./a.out
-0
0
1
1.2
1.23456789e-08
1234567890000000
1.2345678901234567e-08
1.2345678901234568e+24
$ javac Main.java && java Main
-0
0
1
1.2
1.23456789e-08
1234567890000000
1.2345678901234567e-08
1.2345678901234568e+24

Answer 3

Vous pouvez utiliser un NumberFormat . En définissant les chiffres de fraction minimum à 0, mais en laissant le maximum plus, il faut faire ce que vous voulez.

Il est pas aussi facile printf, mais il devrait fonctionner.

Answer 4

bien, vous pouvez spécifier le nombre de chiffres que vous voulez: « % .2g » affiche 1,2 1,20

Answer 5

Notez que l'utilisation

String.format("%.17g", x).replaceFirst("\\.?0+(e|$)", "$1")

échoue pour 1.2345E-20 (bandes du zéro à partir de l'extrémité, produisant 1.2345E-2). Voici ce que je fini par utiliser dans mon code:

String.format(Locale.US, "%.6g", x).replaceFirst("\\.0+(e|$)", "$1").replaceFirst("(\\.[0-9]*[1-9])(0+)(e|$)", "$1$3")

En fait, je modifié l'expression pour assurer que des zéros à la fin de la partie décimale sont supprimés et découpé dans deux cas. Mais merci de me pointer dans la bonne direction.