Especificadores de formato en Java

Posted on by Rudeus Greyrat

Los especificadores de formato comienzan con un carácter de porcentaje (%) y terminan con un «carácter de tipo», que indica el tipo de datos (int, float, etc.) que se convertirán, la forma básica en que se representarán los datos (decimal, hexadecimal, etc.)
La sintaxis general de un especificador de formato es

% [flags] [width] [.precision] [argsize] typechar

El método format() de la clase Formatter acepta una amplia variedad de especificadores de formato. Cuando se utiliza un especificador de mayúsculas, las letras se muestran en mayúsculas. De lo contrario, los especificadores de mayúsculas y minúsculas realizan la misma conversión.

Especificador de formato Conversión aplicada
%% Inserta un signo de %
%x %X entero hexadecimal
%t %T Hora y fecha
%s %S Cuerda
%norte Inserta un carácter de nueva línea
%o entero octal
%F punto flotante decimal
%e %e Notación cientifica
%gramo Hace que Formatter use %f o %e, el que sea más corto
%S.S Código hash del argumento
%d entero decimal
%C Personaje
%b %b booleano
%a %a Hexadecimal de coma flotante
  1. Especificador de formato de espacio: al crear columnas de números, a veces es muy útil imprimir un espacio antes de un número positivo para que los números positivos y negativos se alineen. Para hacer esto, se puede usar el especificador de formato de espacio.

    Sintaxis:

    Formatter().format("% d", -111);
Formatter().format("% d", 111);

Output:
-111
 111

    Ejemplo:

    // Java program to demonstrate
    // the space format specifier
      
    import java.util.*;
      
    class GFG {
        public static void main(String args[])
        {
      
            // create Formatter class object
            Formatter formatter = new Formatter();
      
            // Use Space format specifier
            formatter.format("%d", -111);
            System.out.println(formatter);
      
            formatter = new Formatter();
            formatter.format("% d", 111);
            System.out.println(formatter);
      
            formatter = new Formatter();
            formatter.format("% d", -222);
            System.out.println(formatter);
      
            formatter = new Formatter();
            formatter.format("% d", 222);
            System.out.println(formatter);
        }
    }
    Producción:

    -111
 111
-222
 222
  2. Especificador de signo +: agrega el signo + antes del valor numérico positivo y no tiene ningún efecto sobre el valor numérico negativo.

    Sintaxis:

    Formatter().format("%+d", 111);

Output:
+111

    Ejemplo:

    // Java program to demonstrate
    // the + sign Specifier format specifiers.
      
    import java.util.*;
      
    class GFG {
        public static void main(String args[])
        {
      
            // create Formatter class object
            Formatter formatter = new Formatter();
      
            // + sign specifier
            formatter = new Formatter();
            formatter.format("%+d", 111);
            System.out.println(formatter);
      
            // + sign specifier
            // on - sign, it will have no effect
            formatter = new Formatter();
            formatter.format("%+d", -111);
            System.out.println(formatter);
        }
    }
    Producción:

    +111
-111
  3. ( especificador: este especificador coloca los valores numéricos negativos entre paréntesis y no tiene ningún efecto sobre los valores numéricos positivos.

    Sintaxis:

    Formatter().format("%(d", -111);
Formatter().format("%(d", 111);

Output:
(111)
111

    Ejemplo:

    // Java program to demonstrate
    // the ( Specifiers format specifiers.
      
    import java.util.*;
      
    class GFG {
        public static void main(String args[])
        {
      
            // create Formatter class object
            Formatter formatter = new Formatter();
      
            // ( Specifier
            formatter = new Formatter();
            formatter.format("%(d", -111);
            System.out.println(formatter);
      
            formatter = new Formatter();
            formatter.format("%(d", 111);
            System.out.println(formatter);
        }
    }
    Producción:

    (111)
111
  4. Coma, especificador: para mostrar números grandes, a menudo es útil agregar separadores de agrupación por coma (,). Por ejemplo, el valor es 1000000 más fácil de leer cuando se formatea como 1, 000, 000. Para agregar especificadores de agrupación (, ) use el especificador de coma (, ).

    Sintaxis:

    Formatter().format("%, d", 1000000);

Output:
1, 000, 000

    Ejemplo:

    // Java program to demonstrate
    // the comma format specifiers.
      
    import java.util.*;
      
    public class GFG {
        public static void main(String args[])
        {
      
            // create Formatter class object
            Formatter formatter = new Formatter();
      
            // comma Specifier
            formatter = new Formatter();
            formatter.format("%, d", 1000000);
            System.out.println(formatter);
      
            // comma Specifier
            formatter = new Formatter();
            formatter.format("%, .3f", 32659526566.4521);
            System.out.println(formatter);
        }
    }
    Producción:

    1, 000, 000
32, 659, 526, 566.452
  5. Especificador de justificación izquierda (-): de forma predeterminada, toda la salida se desplaza a la derecha. Es decir, si el ancho del campo es más largo que los datos impresos, los datos se colocarán en el lado derecho del campo. Se puede forzar que la salida se justifique a la izquierda colocando un signo menos justo después del %. Por ejemplo, %-20.4f izquierda justifica un número de punto flotante con dos lugares decimales en un campo de 20 caracteres.

    Sintaxis:

    Formatter().format("|%-20.4f|", 1234.1234);

Output:
|           1234.1234|
|1234.1234           |

    Ejemplo:

    // Java program to demonstrate
    // the left justification format specifiers.
      
    import java.util.*;
      
    class GFG {
        public static void main(String args[])
        {
      
            // create Formatter class object
            Formatter formatter = new Formatter();
      
            // right justify by default
            formatter = new Formatter();
            formatter.format("|%20.4f|", 1234.1234);
            System.out.println(formatter);
      
            // left justify
            formatter = new Formatter();
            formatter.format("|%-20.4f|", 1234.1234);
            System.out.println(formatter);
        }
    }
    Producción:

    |           1234.1234|
|1234.1234           |
  6. Los especificadores de formato %n:
    El especificador de formato %n se diferencia de los demás en que no acepta argumentos. Es simplemente una secuencia de escape que inserta un carácter en la salida. El %n inserta una nueva línea . No se puede ingresar directamente en la string de formato.

    // Java program to demonstrate
    // the newline %n format specifiers.
      
    import java.util.*;
      
    public class GFG {
        public static void main(String args[])
        {
            // create Formatter class object
            Formatter formatter = new Formatter();
      
            // newline format specifier
            formatter.format("Geeks %nFor %nGeeks");
      
            // Print the output
            System.out.println(formatter);
        }
    }
    Producción:

    Geeks 
For 
Geeks
  7. Los especificadores de formato %%:
    El especificador de formato %% se diferencia de los demás en que no acepta argumentos. Es simplemente una secuencia de escape que inserta un carácter en la salida. El %% inserta un signo % . No se puede ingresar directamente en la string de formato.

    // Java program to demonstrate
    // the %% format specifiers.
      
    import java.util.*;
      
    public class GFG {
        public static void main(String args[])
        {
            // create Formatter class object
            Formatter formatter = new Formatter();
      
            // %% format specifier
            formatter.format("10 %% 4 = 2");
      
            // Print the output
            System.out.println(formatter);
        }
    }
    Producción:

    10 % 4 = 2
  8. Los especificadores de formato %x %X:
    El especificador de formato %x o %X se utiliza para representar el valor hexadecimal entero. %x muestra los valores hexadecimales con letras en minúsculas, mientras que el especificador %X muestra los valores hexadecimales con letras en mayúsculas.

    // Java program to demonstrate
    // the integer-Hexadecimal %x and %X
    // format specifiers.
      
    import java.util.*;
      
    public class GFG {
        public static void main(String args[])
        {
            // create Formatter class object
            Formatter formatter = new Formatter();
      
            // %x format specifier
            // It prints the number in Hexadecimal
            // with lowercase alphabets
            formatter.format("%x", 250);
      
            // Print the output
            System.out.println("LowerCase Hexadecimal"
                               + " using %x: "
                               + formatter);
      
            // %X format specifier
            // It prints the number in Hexadecimal
            // with uppercase alphabets
            formatter = new Formatter();
            formatter.format("%X", 250);
      
            // Print the output
            System.out.println("UpperCase Hexadecimal"
                               + " using %X: "
                               + formatter);
        }
    }
    Producción:

    LowerCase Hexadecimal using %x: fa
UpperCase Hexadecimal using %X: FA
  9. Los especificadores de formato %e %E:
    El especificador de formato %e o %E se utiliza para representar la notación científica de un valor. %e muestra la notación científica con letras en minúsculas, mientras que el especificador %E muestra la notación científica con letras en mayúsculas.

    // Java program to demonstrate
    // the Scientific Notation %e and %E
    // format specifiers.
      
    import java.util.*;
      
    public class GFG {
        public static void main(String args[])
        {
            // create Formatter class object
            Formatter formatter = new Formatter();
      
            // %e format specifier
            // It prints the number in Scientific Notation
            // with lowercase alphabets
            formatter.format("%e", 123.1234);
      
            // Print the output
            System.out.println("LowerCase Scientific Notation"
                               + " using %e: "
                               + formatter);
      
            // %E format specifier
            // It prints the number in Scientific Notation
            // with uppercase alphabets
            formatter = new Formatter();
            formatter.format("%E", 123.1234);
      
            // Print the output
            System.out.println("UpperCase Scientific Notation"
                               + " using %E: "
                               + formatter);
        }
    }
    Producción:

    LowerCase Scientific Notation using %e: 1.231234e+02
UpperCase Scientific Notation using %E: 1.231234E+02
  10. Formatos
    de precisión Se puede aplicar un especificador de precisión a los especificadores de formato %f, %e, %gy %s .

    // Java program to demonstrate
    // Prrecision Format specifiers
      
    import java.util.Formatter;
      
    public class GFG {
        public static void main(String args[])
        {
      
            // Create the Formatter instance
            Formatter formatter = new Formatter();
      
            // added floating-point data
            // using the %f or %e specifiers,
            // Format to 2 decimal places
            // in a 16 character field.
            formatter = new Formatter();
            formatter.format("%16.2e", 123.1234567);
            System.out.println("Scientific notation to 2 places: "
                               + formatter);
      
            // Format 4 decimal places.
            formatter = new Formatter();
            formatter.format("%.4f", 123.1234567);
            System.out.println("Decimal floating-point"
                               + " notation to 4 places: "
                               + formatter);
      
            // Format 4 places.
            // The %g format specifier causes Formatter
            // to use either %f or %e, whichever is shorter
            formatter = new Formatter();
            formatter.format("%.4g", 123.1234567);
            System.out.println("Scientific or Decimal floating-point "
                               + "notation to 4 places: "
                               + formatter);
      
            // Display at most 15 characters in a string.
            formatter = new Formatter();
            formatter.format("%.15s", "12345678901234567890");
            System.out.println("String notation to 15 places: "
                               + formatter);
      
            // Format into 10 digit
            formatter = new Formatter();
            formatter.format("%010d", 88);
            System.out.println("value in 10 digits: "
                               + formatter);
        }
    }
    Producción:

    Scientific notation to 2 places:         1.23e+02
Decimal floating-point notation to 4 places: 123.1235
Scientific or Decimal floating-point notation to 4 places: 123.1
String notation to 15 places: 123456789012345
value in 10 digits: 0000000088

Artículo relacionado: Especificadores de formato en C

Publicación traducida automáticamente

Artículo escrito por Rajput-Ji y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *