DecimalFormat

De ChuWiki
Saltar a: navegación, buscar

La clase DecimalFormat de java nos permite mostrar los números en pantalla con el formato que queramos, por ejemplo, con dos decimales, con una coma para separar los decimales, etc. DecimalFormat también es útil para presentar un número en un JTextField o recoger el texto del JTextField y reconstruir el número. Veamos unos ejemplos.

Redondear decimales, por ejemplo, dos decimales

Antes de nada, dejar claro que por ejemplo, usar dos decimales en java, no es algo que se haga con las variables o el código. En código se usa double o float con todos sus decimales y lo único que se hace es, a la hora de presentarlo en pantalla, imprimirlo o mostrarlo en alguna ventana de nuestra aplicación, darle el formato que queramos, el formato de dos decimales, con separador de miles y coma decimal, o el que queramos. Para ello, la clase DecimalFormat de java es la clase que debemos usar.

Un uso simple de DecimalFormat puede ser este

import java.text.DecimalFormat;
...
DecimalFormat formateador = new DecimalFormat("####.##");

// Esto sale en pantalla con dos decimales, es decir, 3,43
System.out.println (formateador.format (3.43242383));

Hemos cogido un número con muchos decimales y lo hemos redondeado a dos decimales para sacarlo por pantalla. Para ello, sólo hemos tenido que indicar la máscara ####.## en el constructor de la clase DecimalFormat. Las # representan una cifra, así que hemos puesto que el número se ponga en pantalla con cuatro cifras, un punto decimal y dos decimales.

En la API de DecimalFormat podemos ver todos los posibles caracteres que admite la máscara.

Si usamos ceros en vez de #, los huecos se rellenarán con ceros por delante.

import java.text.DecimalFormat;
...
DecimalFormat formateador = new DecimalFormat("0000.00");

// Esto sale en pantalla con cuatro cifras enteras
// y cuatro decimales, es decir, 0003,40
System.out.println (formateador.format (3.4));

Al poner 0 en vez de #, las cifras que falten por delante o por detrás, se pondrán con ceros. Es una forma, por ejemplo, de obligar a presentar con dos decimales aunque el número sólo tenga uno o ninguno.

Por supuesto, podemos poner # en la parte entera y 0 en la parte decimal, para que salgan dos decimales aunque sean ceros, pero no se rellenen por delante los ceros de la parte entera.

Mostrar porcentajes

Una característica curiosa, es que si usamos en la máscara el signo de porcentaje %, el número se multiplicará automáticamente por 100 al presentarlo en pantalla.

 DecimalFormat formateador = new DecimalFormat("###.##%");
 
 // Esto saca en pantalla 34,44%
 System.out.println (formateador.format(0.3444));

Redondeo al fijar el número de decimales

Como hemos visto al principio, con DecimalFormat podemos indicar cuántos decimales queremos mostrar en la salida. Un detalle a tener en cuenta es que la clase DecimalFormat es lo suficientemente lista como para redondear, es decir, incrementar en uno el último decimal visible si es necesario. Por ejemplo, si queremos dos decimales, el número 1.2345 se verá como 1.23, pero si la cifra del tercer decimal es 5 o más, como por ejemplo en 1.2356, entonces el resultado será 1.24. El siguiente código nos lo muestra

      double a = 1.2345;
      double b = 1.2356;
      
      DecimalFormat formatter = new DecimalFormat("#.##");
      
      System.out.println(formatter.format(a));   // La salida es 1,23
      System.out.println(formatter.format(b));   // La salida es 1,24

Puntos decimales y separador de miles : DecimalFormatSymbols

La clase DecimalFormat usa por defecto el formato para el lenguaje que tengamos instalado en el ordenador. Es decir, si nuestro sistema operativo está en español, se usará la coma para los decimales y el punto para los separadores de miles. Si estamos en inglés, se usará el punto decimal.

Una opción para cambiar esto, es crear una clase DecimalFormatSymbols, que vendrá rellena con lo del idioma por defecto, y cambiar en ella el símbolo que nos interese. Por ejemplo, si estamos en español y queremos usar el punto decimal en vez de la coma, podemos hacer esto

import java.text.DecimalFormat;
import java.text.DecimalFormatSymbols;
...
DecimalFormatSymbols simbolos = new DecimalFormatSymbols();
simbolos.setDecimalSeparator('.');
DecimalFormat formateador = new DecimalFormat("####.####",simbolos);

// Esto sale en pantalla con punto decimal, es decir, 3.4324,
System.out.println (formateador.format (3.43242383));

En la API de DecimalFormatSymbols puedes ver qué más símbolos se pueden cambiar.

También es posible coger el DecimalFormaSymbols de alguna localización concreta que nos interese y modificar o no lo que haga falta. Por ejemplo, si nos interesa que la coma decimal sea un punto en vez de una coma, podríamos coger el DecimalFormatSymbols de Inglaterra

DecimalFormatSymbols simbolos = DecimalFormatSymbols.getInstance(Locale.ENGLISH);
DecimalFormat formateador = new DecimalFormat("####.####",simbolos);

Aunque, ojo, esto cambia todo, también cosas como la moneda (libras esterlinas o euros), etc.

Reconstruir el número

Si suponemos que un usuario escribe en un JTextField un número, podemos leerlo y reconstruirlo con DecimalFormat

 JTextField textField = new JTextField();
 ...
 DecimalFormat formateador = new DecimalFormat("####.####");
 String texto = textField.getText();
 try
 {
    // parse() lanza una ParseException en caso de fallo que hay
    // que capturar.
    Number numero = formateador.parse(texto);
    double valor = numero.doubleValue();
    // Estas dos líneas se puede abreviar con
    // double valor = formateador.parse(texto).doubleValue();
 }
 catch (ParseException e)
 {
    // Error. El usuario ha escrito algo que no se puede convertir
    // a número.
 }