1. Introducción
En la vida real rara vez necesitamos ver largas «colas» de decimales. Por ejemplo, si calculas el precio de un producto, un salario, una nota media o el área de una habitación, — normalmente basta con un par de decimales y no con 15.
Por ejemplo, el resultado de una división:
double x = 10.0 / 3.0;
System.out.println(x); // 3.3333333333333335
Un usuario que vea un resultado así puede asustarse y pensar que el programa se ha vuelto loco. Por eso a menudo hay que redondear los números — al entero más cercano, a dos decimales, etc.
En Java hay varias herramientas prácticas para ello.
2. Método Math.round(): redondeo al entero más cercano
La forma más sencilla de redondear un número es usar el método Math.round(). Acepta un número de coma flotante (tanto float como double) y devuelve el entero más cercano.
Cómo funciona Math.round
- Si la parte fraccionaria es menor que 0.5, redondea hacia abajo.
- Si la parte fraccionaria es 0.5 o mayor, redondea hacia arriba.
Ejemplos:
System.out.println(Math.round(2.3)); // 2
System.out.println(Math.round(2.7)); // 3
System.out.println(Math.round(2.5)); // 3
System.out.println(Math.round(-2.5)); // -2
Tipo de valor devuelto
- Si pasas un float, devuelve int.
- Si pasas un double, devuelve long.
float f = 5.8f;
int roundedF = Math.round(f); // 6
double d = 5.8;
long roundedD = Math.round(d); // 6
Atención: a veces esto sorprende — ¡has redondeado un double y obtienes un long! Si necesitas un int, tendrás que hacer una conversión explícita:
int rounded = (int) Math.round(5.6); // 6
3. Redondeo a un número determinado de decimales
A menudo hay que redondear no al entero, sino, por ejemplo, a dos decimales (para dinero, porcentajes, etc.).
En Java no hay un método «mágico» como Math.roundTo2Digits(), pero se puede hacer manualmente.
Método 1: truco matemático con multiplicar y dividir
- Multiplica el número por 100 (si necesitas dos decimales).
- Redondea al entero con Math.round.
- Divide de nuevo entre 100.
Ejemplo:
double value = 3.14159;
double rounded = Math.round(value * 100.0) / 100.0;
System.out.println(rounded); // 3.14
Cómo funciona:
- 3.14159 * 100 = 314.159
- Math.round(314.159) = 314
- 314 / 100.0 = 3.14
4. Formateo de números: clase DecimalFormat
A veces no solo hay que redondear un número, sino también mostrarlo de forma cuidada — con un número concreto de decimales, ceros a la izquierda, separadores de miles, etc. Para ello, en Java existe la clase DecimalFormat del paquete java.text.
Cómo funciona DecimalFormat
- Crea un objeto con el patrón deseado.
- Llama a su método format(...).
import java.text.DecimalFormat;
double value = 3.14159;
DecimalFormat df = new DecimalFormat("0.00");
System.out.println(df.format(value)); // 3.14
Cómo se construye el patrón
- "0.00" — siempre dos decimales (aunque el número sea entero).
- "0.###" — hasta tres decimales; no se muestran ceros sobrantes.
- "#,##0.00" — añade separadores de miles (por ejemplo, "1,234.56").
Ejemplos de distintos patrones:
| Patrón | Número | Resultado |
|---|---|---|
|
2 | 2.00 |
|
2.5 | 2.50 |
|
2.567 | 2.57 |
|
2.567 | 2.567 |
|
2.5 | 2.5 |
|
12345.678 | 12,345.68 |
Ejemplo con separadores de miles
DecimalFormat df = new DecimalFormat("#,##0.00");
System.out.println(df.format(1234567.89)); // 1,234,567.89
Ejemplo: salida sin ceros de más
DecimalFormat df = new DecimalFormat("0.##");
System.out.println(df.format(3.1)); // 3.1
System.out.println(df.format(3.141)); // 3.14
System.out.println(df.format(3.145)); // 3.15
5. Formateo con String.format
A veces, para casos sencillos, resulta cómodo usar String.format, una forma integrada de formatear cadenas, similar a printf en otros lenguajes.
double value = 3.14159;
System.out.println(String.format("%.2f", value)); // 3.14
Aquí "%.2f" significa «mostrar el número con dos decimales».
Comparación de enfoques:
- DecimalFormat — más potente; admite patrones y localización; útil para separadores de miles.
- String.format — más simple si solo necesitas fijar el número de decimales.
6. Particularidades del redondeo: Math.floor, Math.ceil, Math.rint
- Math.floor(x) — redondea hacia abajo (al menor), también para números negativos.
- Math.ceil(x) — redondea hacia arriba (al mayor).
- Math.rint(x) — redondea al entero más cercano, pero devuelve double.
Ejemplos:
System.out.println(Math.floor(2.7)); // 2.0
System.out.println(Math.ceil(2.1)); // 3.0
System.out.println(Math.rint(2.5)); // 2.0 (sí, sí, no es un error tipográfico)
System.out.println(Math.rint(3.5)); // 4.0
Atención: Math.rint a veces redondea «al más cercano par» — esta regla (el llamado banker's rounding) ayuda a reducir la acumulación de errores en cálculos masivos.
7. Detalles útiles
Visualización: tabla de redondeos
| Número | Math.round | Math.floor | Math.ceil | Math.rint |
|---|---|---|---|---|
| 2.3 | 2 | 2.0 | 3.0 | 2.0 |
| 2.5 | 3 | 2.0 | 3.0 | 2.0 |
| 3.5 | 4 | 3.0 | 4.0 | 4.0 |
| -2.3 | -2 | -3.0 | -2.0 | -2.0 |
| -2.5 | -2 | -3.0 | -2.0 | -2.0 |
¡Redondeo no es lo mismo que formateo!
Es muy importante entender la diferencia entre redondeo y formateo.
- Redondeo — cambiar el valor del número (por ejemplo, 2.718 → 2.72).
- Formateo — cambiar solo cómo se muestra el número (por ejemplo, 2.718 → "2.72" en pantalla, pero en memoria sigue siendo 2.718).
double x = 2.718;
System.out.println(String.format("%.2f", x)); // 2.72
System.out.println(x); // 2.718
Si quieres usar el número redondeado en cálculos posteriores, redondéalo matemáticamente. Si es solo para mostrarlo, formátalo.
8. Errores típicos al redondear y formatear números
Error n.º 1: Redondeaste solo para mostrar y luego usas el número «largo».
Situación muy frecuente: mostrar en pantalla un valor bien formateado y, a continuación, usar el número original «largo» en los cálculos. Para importes, puntuaciones y totales — primero redondea (por ejemplo, con Math.round o el truco de multiplicar/dividir) y después guarda/entrega el valor al usuario.
Error n.º 2: Esperar que Math.round(x) devuelva un double con dos decimales.
Math.round() siempre redondea al entero más cercano: para float devuelve int, para double — long. Para dos decimales usa multiplicar/dividir o el formateo.
Error n.º 3: Usar DecimalFormat para cálculos.
DecimalFormat.format() devuelve una cadena. No puedes usarla en aritmética: obtendrás un error de compilación o una NumberFormatException al analizarla de vuelta.
Error n.º 4: Patrón DecimalFormat incorrecto.
El patrón debe ajustarse a lo esperado: "0.00" siempre mostrará dos decimales ("2.00"), y "0.##" eliminará los ceros sobrantes ("2", "2.1", "2.12").
Error n.º 5: Pérdida de precisión al dividir entre 100.
Si divides un int entre un int, ¡el resultado también es int!
int a = 5;
System.out.println(a / 2); // 2, no 2.5!
Para que la división sea «con decimales», al menos uno de los operandos debe ser double:
int a = 5;
System.out.println(a / 2.0); // 2.5
GO TO FULL VERSION