Qual è l'equivalente Java di printf% formato g identificatore di C?

Question

Ho provato ad utilizzare Formatter.format, ma che sembra lasciare la mantissa su numeri con 0 mantissa, mentre la versione C non lo fa. Esiste un equivalente di% g di formato di C in Java, e in caso contrario, c'è un modo di fingere? La mia intenzione è quella di preservare la mantissa esattamente come C di per ragioni di 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

Allo stesso modo, con 1,2 come input, la mantissa è più lunga nella versione di Java

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

Answer 1

Hai provato la java.text.DecimalFormat classe ?

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

uscite:

1

considerando quanto segue:

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

uscite:

1.2

Answer 2

modifica : Questo codice fa sì che la parte frazionaria di andare mancare se l'esponente è 17 cifre, a causa della mia incomprensione di come String.Format formattata quei numeri. Quindi non prega di non utilizzare questo codice:

Grazie per l'ingresso, ragazzi. Non riuscivo a trovare un modo per configurare DecimalFormat o NumberFormat per clonare esattamente la funzionalità, ma sembra che questo metodo funziona (seguito da un esempio):

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

e le loro uscite:

$ 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

È possibile utilizzare un NumberFormat . Impostando le cifre minime di frazione a 0, ma lasciando la massima più grande, che dovrebbe fare quello che vuoi.

Non è così facile come printf, ma dovrebbe funzionare.

Answer 4

bene, è possibile specificare il numero di cifre che si desidera: "% .2g" visualizzerà 1.2 da 1.20

Answer 5

Si noti che usare

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

fallisce per 1.2345e-20 (strisce lo zero dalla fine, producendo 1.2345e-2). Ecco quello che ho finito per usare nel mio codice:

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

Fondamentalmente ho modificato l'espressione di assicurare solo zeri alla fine della parte frazionaria vengono rimossi e diviso questo in due casi. Ma grazie per avermi nella giusta direzione.