Redondear números en Java

Los números de coma flotante (flotante, doble) se utilizan al calcular expresiones que requieren precisión decimal. A menudo se necesita una alta precisión en la contabilidad y otras operaciones informáticas. Pero, ¿necesitamos siempre una larga “cola” de números después del punto decimal? ¿Quizás nos baste con una precisión de tres partes reales? Y estamos satisfechos con esta opción, ¿cómo realizar correctamente el redondeo? Esto es exactamente de lo que hablaremos hoy: veremos formas de redondear números en Java .

Formato de cadena

Como primer método, veremos el redondeo al doble:

double value = 34.766674;
String result = String.format("%.3f",value);
System.out.print(result);//  34,767

Como resultado, formatearemos nuestro número de coma flotante 34766674 con una precisión de 3 decimales , ya que en las instrucciones de formato especificamos tres decimales "%.3f. A su vez, %f al formatear una cadena indica el tipo de coma flotante números, que incluye el tipo de datos double y float en Java. En el ejemplo anterior, enviamos el valor resultante a la consola. Ahora la pregunta es: ¿cómo podríamos acortar esto? Es simple: necesitas usar printf, que a su vez es formato + imprimir. Como resultado, el ejemplo anterior se reduciría a:

double value = 34.766674;
System.out.printf("%.3f",value);

Además de este método , la instancia out de la clase PrintStream también tiene un método de formato, que funciona de manera similar:

double value = 34.766674;
System.out.format("%.3f",value);

El redondeo se produce en el modo HALF_UP , hacia el número que está más cerca del que se corta (a 0 o 10). Si estos números son equidistantes (en el caso de 5), entonces se realiza el redondeo. Ejemplo:

String firstResult = String.format("%.3f",7.0004);// 7,000
String secondResult = String.format("%.3f",7.0005);// 7,001
String thirdResult = String.format("%.3f",7.0006);// 7,001

Analizaremos los modos de redondeo con más detalle a continuación.

Formato decimal

Otra opción es utilizar la clase DecimalFormat . Está diseñado para formatear cualquier número en Java, ya sea un número entero o de punto flotante. Cuando creamos una instancia de DecimalFormat, podemos pasarle una cadena de formato. Indicará cuántos decimales formatear para la entrada. Así es como se vería nuestro ejemplo usando DecimalFormat :

double value = 34.766674;
DecimalFormat decimalFormat = new DecimalFormat( "#.###" );
String result = decimalFormat.format(value);
System.out.print(result);//34,767

La línea #.### es un patrón que indica que estamos formateando el valor pasado con 3 decimales. Para cambiar el patrón después de crear el objeto DecimalFormat, puede utilizar sus métodos applyPattern y applyLocalizedPattern :

DecimalFormat decimalFormat = new DecimalFormat("#.###");
decimalFormat.applyPattern("#.#");
decimalFormat.applyLocalizedPattern("#.#####");

Pero hoy hablamos de redondeo, ¿no? Al truncar un número con decimales más allá del patrón especificado, DecimalFormat redondea el número hacia arriba si el último número truncado es mayor que 5. Pero, ¿qué pasa si el número es 5? Resulta que está exactamente en el medio entre los números enteros más cercanos. ¿Entonces que? En este caso se tiene en cuenta el número anterior. Si es par se redondea:

DecimalFormat decimalFormat = new DecimalFormat("#.###");
String result = decimalFormat.format(7.4565);
System.out.println((result));// 7,457

Si es impar no se realiza:

DecimalFormat decimalFormat = new DecimalFormat("#.###");
String result = decimalFormat.format(7.4575);
System.out.println((result));// 7,457

Existe una ligera diferencia entre formatear números de coma flotante usando String.format() y DecimalFormat.format(). El primero siempre imprimirá ceros finales incluso si no hay una parte fraccionaria. P.ej:

String firstResult = String.format("%.3f", 7.000132);
System.out.println((firstResult)); // 7.000

DecimalFormat decimalFormat = new DecimalFormat("#.###");
String secondResult = decimalFormat.format(7.000132);
System.out.println((secondResult));  // 7

Como podemos ver, al formatear el número 7.000132 con tres decimales, el método format() de String generará 7.000, mientras que el método format() de DecimalFormat generará 7. Es decir, puede elegir String.format() o DecimalFormat.format( ) dependiendo de si necesita ceros finales o no. Usando los métodos descritos anteriormente, obtuvimos el resultado en forma de cadena. Veamos formas de recuperar exactamente los valores numéricos.

Matemáticas

Es imposible no mencionar una clase especial diseñada para diversas operaciones aritméticas con números: Matemáticas . Esta clase también tiene métodos para redondear, pero a diferencia de los ya descritos, no permiten establecer un número determinado de decimales, sino que redondean a un número entero:

• Math.ceil() redondea al entero más cercano, pero no devuelve un tipo entero, sino un doble:

  double value = 34.777774;
  double result = Math.ceil(value);
  System.out.println((result)); //35.0

  Incluso si tenemos 34.0000000, después de usar Math.ceil todavía obtendremos 35.0.

  Math.floor() redondea hacia abajo al entero más cercano y también devuelve el resultado como doble:

  double value = 34.777774;
  double result = Math.floor(value);
  System.out.println((result)); //34.0

  Nuevamente, incluso si tenemos un valor de 34,999999999, luego de usar Math.floor obtendremos 34,0.

• Math.round () : redondea al número entero más cercano, dando el resultado int:

  double value = 34.777774;
  int result = Math.round(value);
  System.out.println((result)); //35

  Si nuestro número es 34,5, se redondea a 35, pero si es ligeramente menor que 34,499, el número se trunca a 34.

  Para no simplemente cortar toda la parte real, sino regular este proceso a un cierto número de decimales y al mismo tiempo redondear, el número se multiplica por 10^n (10 elevado a n), donde n es igual al número de decimales necesarios. Después de esto, se utiliza algún método de la clase Math para redondear y luego dividir nuevamente entre 10^n:

  double value = 34.777774;
  double scale = Math.pow(10, 3);
  double result = Math.ceil(value * scale) / scale;
  System.out.println((result)); //34.778

  Math.pow : toma dos argumentos. El primero es el número, el segundo es la potencia a la que hay que elevarlo.

Redondeo con BigDecimal

BigDecimal es una clase que te permite trabajar con números de coma flotante. En particular, su característica principal es que puede almacenar números fraccionarios de longitud arbitraria (es decir, no hay límite en el rango del número). Además, esta clase almacena varios métodos de procesamiento aritmético, incluido el redondeo. La clase de este objeto se puede crear configurando el constructor en double, string para mostrar un número de coma flotante, double y MathContext , etc. MathContext es una combinación de RoundingMode y un número que describe el número total de dígitos en el valor buscado. Reglas de redondeo Modo de redondeo: ABAJO : redondeo hacia cero. ARRIBA: modo de redondeo desde cero. TECHO : redondeo hacia el infinito positivo. PISO : redondeo hacia el infinito negativo. HALF_UP : redondea al "vecino más cercano" si ambos vecinos no son equidistantes (es decir, cuando el número que se redondea es 5). En este caso se realiza el redondeo. HALF_DOWN : redondeo hacia el "vecino más cercano". Si ambos vecinos no son equidistantes, en este caso redondea hacia abajo. HALF_EVEN : redondea al "vecino más cercano" si ambos vecinos no son equidistantes. En este caso, redondee al vecino par (como en DecimalFormat descrito anteriormente). INNECESARIO - Se utiliza para confirmar que la operación solicitada tiene el resultado correcto. Por lo tanto, no es necesario redondear. Ejemplo:

MathContext context = new MathContext(5, RoundingMode.HALF_UP);
double value = 34.777554;
BigDecimal result = new BigDecimal(value, context);
System.out.println(result); //34.778

Además de la capacidad de establecer una regla de redondeo en el constructor, BigDecimal le permite configurar el modo de redondeo después de crear la instancia. Para hacer esto, use el método setScale , en el que necesita establecer el número de decimales y las reglas de redondeo:

double value = 34.777554;
BigDecimal result = new BigDecimal(value);
result = result.setScale(3, RoundingMode.DOWN);
System.out.println(result); //34.777

BigDecimal también tiene variables int internas diseñadas para establecer el modo de redondeo ( ROUND_DOWN , ROUND_CEILING , ROUND_FLOOR ...). Estas son reglas de redondeo similares a las presentadas en la clase RoundingMode y se usan de manera similar en setScale :

BigDecimal result = new BigDecimal(value);
result = result.setScale(3, BigDecimal.ROUND_DOWN);

Lea más sobre la clase BigDecimal en este artículo .