Clase principal utilizada: java.text.decimalformat
1. Para instanciar un objeto, puede usar los siguientes dos métodos:
La copia del código es la siguiente:
DecimalFormat df = (decimalFormat) numberFormat.getInstance ();
Decimalformat df1 = (decimalFormat) decimalFormat.getInstance ();
Porque decimalformat hereda de numberFormat.
2. Establezca el número de decimales
El sistema predeterminado a los lugares decimales es 3, como:
La copia del código es la siguiente:
DecimalFormat df = (decimalFormat) numberFormat.getInstance ();
System.out.println (df.format (12.3456789));
Salida: 12.346
Ahora puede establecer el decimal en dos dígitos mediante el siguiente método:
La copia del código es la siguiente:
df.SetMaximumFractionDigits (2);
System.out.println (df.format (12.3456789));
Entonces la salida es: 12.35
3. Hay dos formas de convertir los números en salida porcentual:
(1)
La copia del código es la siguiente:
df.applypattern ("##. ##%");
System.out.println (df.format (12.3456789));
System.out.println (df.format (1));
System.out.println (df.format (0.015));
Las salidas son: 1234.57% 100% 1.5%
(2)
La copia del código es la siguiente:
df.SetMaximumFractionDigits (2);
System.out.println (df.format (12.3456789*100)+"%");
System.out.println (df.format (1*100)+"%");
System.out.println (df.format (0.015*100)+"%");
Las salidas son:
1,234.57% 100% 1.5%
4. Establecer el tamaño del grupo
La copia del código es la siguiente:
Decimalformat df1 = (decimalFormat) decimalFormat.getInstance ();
df1.setGroupingSize (2);
System.out.println (DF1.Format (123456789));
Salida: 1,23,45,67,89
También puede deshabilitar la configuración de agrupación por DF1.SetGroupingUsed (falso);
La copia del código es la siguiente:
Decimalformat df1 = (decimalFormat) decimalFormat.getInstance ();
df1.setGroupingSize (2);
df1.setGroupingUsed (falso);
System.out.println (DF1.Format (123456789));
Salida: 123456789
5. Establezca el decimal en 2 dígitos
La copia del código es la siguiente:
DecimalFormat df2 = (decimalFormat) decimalFormat.getInStance ();
df2.applypattern ("0.00");
System.out.println (df2.format (1.2));
Salida: 1.20
A veces necesitamos controlar el formato de los números de salida.
Tal vez no le importe el formato, pero debe preocuparse por que su programa sea universal en todo el mundo.
System.out.println (1234.56);
En los Estados Unidos, "." ¿Cómo lidiar con esto?
Algunos paquetes en el paquete Java.Text pueden manejar este tipo de problema. El siguiente ejemplo simple usa esas clases para resolver el problema planteado anteriormente:
La copia del código es la siguiente:
import java.text.numberFormat;
import java.util.locale;
clase pública decimalFormat1 {
public static void main (string args []) {
// Obtener el formato predeterminado local
NumberFormat nf1 = numberFormat.getInStance ();
System.out.println (NF1.Format (1234.56));
// Obtener el formato alemán
NumberFormat nf2 =
NumberFormat.getInstance (locale.german);
System.out.println (nf2.format (1234.56));
}}
Si está en los Estados Unidos, después de ejecutar el programa, salida:
1.234.56
1.234,56
En otras palabras, use diferentes hábitos para representar números en diferentes lugares.
El método NumberFormat.getInstance () devuelve una instancia de NumberFormat (en realidad una subclase específica de NumberFormat, como DecimalFormat), que es adecuada para formatear un número basado en la configuración local. También puede usar entornos regionales no defensores, como Alemania. El método de formato luego formatea los números de acuerdo con reglas regionales específicas. Este programa también se puede usar en una forma simple:
NumberFormat.getInstance (). Formato (1234.56)
Pero guardar un formato y luego reutilizarlo es más eficiente. La internacionalización es un gran problema al formatear números.
Otro es un control efectivo sobre el formato, como especificar el número de dígitos en la parte fraccional.
La copia del código es la siguiente:
import java.text.DecimalFormat;
import java.util.locale;
clase pública decimalFormat2 {
public static void main (string args []) {
// Obtener el formato predeterminado local
Decimalformat df1 = new DecimalFormat ("###. 000");
System.out.println (df1.format (1234.56));
// Obtener el formato alemán
Locale.setDefault (locale.german);
Decimalformat df2 = new DecimalFormat ("###. 000");
System.out.println (df2.format (1234.56));
}
}
En este ejemplo, se establece el formato de número, utilizando símbolos como "####. 000". Este modo significa que hay cuatro números antes del punto decimal. Salida del programa:
1234.560
1234,560
Del mismo modo, los formatos en forma exponencial también se pueden controlar, por ejemplo:
La copia del código es la siguiente:
import java.text.DecimalFormat;
clase pública decimalFormat3 {
public static void main (string args []) {
Decimalformat df = new DecimalFormat ("0.000e0000");
System.out.println (df.format (1234.56));
}
}
Producción:
1.235e0003
Para porcentajes:
La copia del código es la siguiente:
import java.text.numberFormat;
clase pública decimalFormat4 {
public static void main (string args []) {
NumberFormat nf = numberFormat.getPermentInstance ();
System.out.println (NF.Format (0.47));
}
}
Producción:
47%
Hasta ahora, has visto varias técnicas diferentes para formatear números. Por otro lado, ¿cómo leo y analizo una cadena que contiene números formateados? El soporte de resolución se incluye en NumberFormat. Por ejemplo:
La copia del código es la siguiente:
import java.util.locale;
import java.text.numberFormat;
import java.text.parseException;
clase pública decimalFormat5 {
public static void main (string args []) {
// Formato local
NumberFormat nf1 = numberFormat.getInStance ();
Objeco obj1 = nulo;
// análisis basado en formato
intentar {
obj1 = nf1.parse ("1234,56");
}
Catch (ParseException e1) {
System.err.println (E1);
}
System.out.println (obj1);
// formato alemán
NumberFormat nf2 =
NumberFormat.getInstance (locale.german);
Objero obj2 = nulo;
// análisis basado en formato
intentar {
obj2 = nf2.parse ("1234,56");
}
Catch (ParseException e2) {
System.err.println (E2);
}
System.out.println (obj2);
}
}
Este ejemplo se divide en dos partes, que analizan una cadena: "1234,56". La primera parte usa el formato local para analizar, mientras que la segunda parte usa el formato alemán para analizar. Cuando el programa se ejecuta en los Estados Unidos, el resultado es:
123456
1234.56
En otras palabras, "1234,56" se considera un enorme entero de 123456 en los Estados Unidos, y un decimal de "1234.56" en Alemania.
También está la última cuestión de formatear la discusión. En el ejemplo anterior, se utilizan decimalformat y numberFormat. Decimalformat a menudo se usa para obtener un buen control de formato, mientras que NumberFormat a menudo se usa para especificar diferentes regiones que locales. ¿Cómo combinar dos categorías?
La respuesta gira en torno al hecho de que DecimalFormat es una subclase de NumberFormat, cuya instancia se especifica como una región específica. Por lo tanto, puede especificar una región usando NumberFormat.getInstance y luego lanzar la estructura a un objeto decimalformat. La documentación menciona que esta técnica se puede aplicar en la mayoría de los casos, pero debe usar un bloque de try/captura para rodear el elenco en caso de que la conversión no funcione correctamente (presumiblemente usando un área extraña en situaciones muy discretas). Aquí hay un ejemplo como este:
La copia del código es la siguiente:
import java.text.DecimalFormat;
import java.text.numberFormat;
import java.util.locale;
clase pública decimalFormat6 {
public static void main (string args []) {
Decimalformat df = null;
// Obtener un objeto numberFormat y
// lanza a un objeto decimalformat
intentar {
df = (decimalformat)
NumberFormat.getInstance (locale.german);
}
Catch (ClassCastException e) {
System.err.println (e);
}
// Establecer el modo de formato
df.applypattern ("####. 00000");
// formatear un número
System.out.println (df.format (1234.56));
}
}
El método getInstance () obtiene el formato y luego llama al método ApplyPattern () para establecer el modo de formato y salidas:
1234,56000
Si no le importa la internacionalización, puede usar decimalformat directamente.