¿Cuál es el equivalente Java de formato% g printf especificador de C?

Question

He intentado utilizar Formatter.format, pero que parece salir de la mantisa en números con 0 mantisa, mientras que la versión C no lo hace. ¿Hay un equivalente de% g especificador de formato de C en Java, y si no es así, ¿hay alguna manera de fingir? Mi intención es preservar la mantisa exactamente igual que C de por razones de compatibilidad.

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

Consola:

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

Del mismo modo, con 1,2 como entrada, la mantisa es más largo en la versión de Java

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

Answer 1

¿Has probado la java.text.DecimalFormat clase?

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

salidas:

1

Considerando lo siguiente:

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

salidas:

1.2

Answer 2

editar : Este código hace que la parte fraccionaria a ir perdiendo si el exponente es de 17 dígitos, debido a mi falta de comprensión de cómo formatear String.Format esos números. Así que no por favor no utilice este código: P

Gracias por la entrada, chicos. No pude encontrar una manera de configurar DecimalFormat o NumberFormat para clonar exactamente la funcionalidad, pero parece que este método funciona (seguido por un ejemplo):

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

y sus salidas:

$ 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

Se puede usar un NumberFormat . Al establecer los dígitos mínimos de fracciones a 0, pero dejando la máxima más grande, se debe hacer lo que quiera.

No es tan fácil como printf, pero debería funcionar.

Answer 4

bien, puede especificar el número de dígitos que desea: "% .2g" se mostrará como 1,2 1,20

Answer 5

Tenga en cuenta que utilizando

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

falla por 1.2345e-20 (tiras el cero desde el extremo, produciendo 1.2345e-2). Esto es lo que terminó usando en mi código:

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

Básicamente he modificado la expresión para asegurar que sólo ceros al final de la parte fraccionaria se eliminan y dividir este en dos casos. Pero gracias por señalarme en la dirección correcta.