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 |
- 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
- 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
- ( 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
- 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
- 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 |
- 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
- 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
- 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
- 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
- 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