Cómo truncar decimales en Java (casteo a int, Math.floor, BigDecimal setScale)

1. ¿Qué significa “truncar decimales” en Java?

Cuando la gente dice “truncar decimales” en Java, normalmente se refiere a eliminar la parte fraccionaria para obtener un entero o descartar dígitos después del n‑ésimo decimal.
En el código real, sin embargo, “truncar” puede significar más de una cosa, así que aclararemos la conclusión primero.

1.1 ¿“Truncar” significa floor? ¿O cast? (Terminología)

Existen principalmente dos patrones de “truncamiento”.

• (A) Truncamiento hacia 0 (truncate) Elimina la parte fraccionaria, pero para números negativos se mueve “más cerca de cero”. Ejemplos: 3.9 → 3 , -3.9 → -3 → En Java, el casting a (int) se comporta de esta manera
• (B) Truncamiento hacia −∞ (floor) Se desplaza hacia abajo (hacia valores menores) en la recta numérica Ejemplos: 3.9 → 3 , -3.9 → -4 → En Java, Math.floor() se comporta de esta manera

Los principiantes a menudo se confunden porque para números positivos, (A) y (B) producen el mismo resultado.
Pero en el momento en que manejas números negativos, los resultados divergen.

1.2 Qué ayuda a lograr este artículo (ruta más rápida según caso de uso)

Quienes buscan “java truncate decimals” normalmente quieren una de las siguientes cosas.

• Simplemente convertir a entero (p. ej., 3.14 → 3) → El casting con (int) es lo más rápido. Pero hay que tener cuidado con los números negativos.
• Truncar a 2 decimales (p. ej., 1.239 → 1.23) → Math.floor(x * 100) / 100 puede servir → Pero si la precisión es importante, BigDecimal es más seguro
• Dinero/facturación/tarifas donde los errores son inaceptables → Usa BigDecimal + setScale + RoundingMode

Si eliges el método equivocado, a menudo “parece funcionar” pero falla más adelante.
En particular, los cálculos basados en double pueden introducir errores de precisión, por lo que para lógica relacionada con dinero es más seguro diseñar con BigDecimal desde el principio.

1.3 Errores comunes (corrígelos primero)

Tres equivocaciones habituales son:

• Suponer que (int) siempre equivale a floor → En realidad redondea hacia cero, por lo que los números negativos difieren.
• Usar Math.floor para truncar decimales y obtener ligeras discrepancias → A menudo causado por la precisión de double (depende de los valores/entorno).
• Utilizar formateo (DecimalFormat, etc.) como si cambiara el valor calculado → La visualización puede cambiar mientras el valor interno permanece igual.

Primero confirma el camino más corto: “Si solo necesitas un entero, haz casting”. Luego comprende la “trampa de los números negativos”.

En la siguiente sección explicaremos el truncamiento mediante casting a (int) con ejemplos concretos.

2. Si solo quieres un int, el casting funciona (pero hay una trampa)

Si solo deseas eliminar la parte fraccionaria y obtener un entero (int), el enfoque más rápido en Java es el casting (conversión de tipo).
Pero el casting no es “truncamiento matemático (floor)”. Es redondeo hacia cero (truncate), lo cual importa mucho.

2.1 Conceptos básicos: truncar la parte fraccionaria con (int)

Cuando conviertes un double o float a int, la parte fraccionaria se descarta.

double x = 3.99;
int a = (int) x;
System.out.println(a); // 3

Esta es la respuesta más sencilla para la intención común “quiero truncar decimales”.

Los pasos son:

• Confirmar que el valor es un double / float
• Añadir (int) para convertirlo a int
• Verificar el resultado—incluidos los números negativos si pueden aparecer

2.2 Importante: el casting redondea hacia cero (los números negativos difieren)

Esta es la trampa número 1 para los principiantes.
El casting no siempre “redondea al valor menor”.

System.out.println((int) 3.9);   // 3
System.out.println((int) -3.9);  // -3

-3.9 se convierte en -3 (no en -4) porque el casting convierte en la dirección más cercana a cero.

• 3.9 → 3 (hacia cero)
• -3.9 → -3 (hacia cero)

Si deseas “truncamiento matemático (floor)”, necesitas Math.floor(), no el casting.
Si pasas por alto esto, puedes obtener errores en cosas como cálculos de P&L, de comisiones o de coordenadas, donde solo el lado negativo está equivocado.

2.3 Errores comunes: Suponer redondeo / Fallos con negativos

El casting no equivale a redondear al número más cercano.
Si piensas que “0,9 se convierte en 1”, estarás equivocado.

System.out.println((int) 0.9);  // 0
System.out.println((int) 1.9);  // 1

Además, con números negativos puede parecer que el valor “aumentó” o “disminuyó” de forma inesperada.

• -3.9 → -3 se mueve en la dirección mayor en la recta numérica
• Si esperabas -4, eso es un error real

La solución es sencilla:

• Si solo manejas valores positivos → el casting está bien
• Si pueden aparecer valores negativos → considera Math.floor()
• Si se requiere precisión estricta (dinero, etc.) → considera BigDecimal

En la siguiente sección explicaremos Math.floor() / Math.ceil(), que permite truncar de forma matemáticamente consistente incluso con números negativos.

3. Usa Math.floor / Math.ceil para truncar decimales correctamente

Si deseas truncar decimales de forma matemáticamente correcta, el enfoque básico es usar Math.floor() en lugar de casting.
Especialmente cuando pueden aparecer números negativos, elegir simplemente Math.floor() reduce significativamente los errores.

3.1 Truncamiento con Math.floor() (Función piso)

Math.floor() se denomina función piso y redondea los valores hacia abajo (hacia valores menores) en la recta numérica.

System.out.println(Math.floor(3.9));   // 3.0
System.out.println(Math.floor(-3.9));  // -4.0

Puntos clave:

• 3.9 → 3.0 (se mueve hacia abajo)
• -3.9 → -4.0 (se mueve aún más hacia abajo)

La mayor ventaja es que el truncamiento no se comporta de forma inesperada con números negativos.

Una trampa frecuente es que Math.floor() devuelve un double.
Si necesitas un entero, debes convertirlo después.

3.2 Math.ceil() redondea hacia arriba — No lo confundas

Math.ceil() es lo opuesto a Math.floor() y redondea hacia arriba (hacia valores mayores) en la recta numérica.

System.out.println(Math.ceil(3.1));   // 4.0
System.out.println(Math.ceil(-3.1));  // -3.0

Un error común es:

• Pensar que “eliminar decimales” equivale a ceil → En realidad, ceil redondea hacia arriba, lo que a menudo es lo contrario de lo que se desea.

Si buscas “truncar decimales”, floor suele ser la elección correcta.

3.3 Conversión de tipo al convertir a long / int

Si deseas convertir el resultado de Math.floor() a int o long, necesitas hacer un casting.

double x = -3.9;

int a = (int) Math.floor(x);
System.out.println(a); // -4

Aspectos a vigilar:

• El resultado de Math.floor() es un double
• Hacer casting a int elimina la parte decimal (no hay desajuste en esta etapa)
• Si el valor es demasiado grande, puede no caber en un int

Para mayor seguridad, puedes elegir long primero.

double x = 12345678901.9;

long b = (long) Math.floor(x);
System.out.println(b); // 12345678901

Errores habituales incluyen:

• Olvidar hacer el casting y dejar el valor como double
• No comprender la diferencia entre floor y casting, lo que genera fallos con negativos
• Desbordamiento al superar el rango de int

En resumen, si pueden involucrarse números negativos, lo más seguro es diseñar desde el principio alrededor de Math.floor().

En la siguiente sección explicaremos cómo truncar en la n‑ésima posición decimal (por ejemplo, manteniendo dos decimales) con ejemplos concretos.

4. Cómo truncar en la n‑ésima posición decimal (común en visualización y cálculos)

En aplicaciones reales es muy frecuente querer conservar hasta una cierta posición decimal y descartar el resto, no solo eliminar todos los decimales.
Ejemplos incluyen tasas impositivas, tipos de cambio, precios unitarios y porcentajes.

Aquí organizamos formas prácticas de truncar en la n‑ésima posición decimal.
Al usar double, pueden aparecer problemas de precisión, por lo que también abordaremos esas trampas.

4.1 Patrón básico: multiplicar por 10ⁿ, aplicar floor y luego dividir

1. Decida el número de decimales n
2. Multiplique por 10^n
3. Aplique Math.floor()
4. Divida por 10^n para restaurar la escala

Para truncar a 2 decimales (p.ej., 1.239 → 1.23):

double x = 1.239;
double y = Math.floor(x * 100) / 100;
System.out.println(y); // 1.23

Para truncar a 3 decimales (p.ej., 1.2399 → 1.239):

double x = 1.2399;
double y = Math.floor(x * 1000) / 1000;
System.out.println(y); // 1.239

Ventajas de este enfoque:

• Código corto y sencillo
• Utiliza Math.floor(), por lo que el comportamiento con números negativos es consistente
• No se requieren bibliotecas adicionales

Sin embargo, como esto depende de double, no es adecuado para cálculos estrictos como el dinero.

4.2 Trampa: Resultados inesperados debido a la precisión de double

El double de Java es un tipo de punto flotante y no siempre puede representar valores como 0.1 o 0.01 de forma exacta.
Como resultado, puede observar discrepancias aparentemente “sin sentido” (dependiendo de los valores y del entorno).

• Usted espera 1.29, pero aparece como 1.28
• Usted maneja 0.3, pero internamente es 0.299999999...

Por ejemplo, el siguiente código parece lógicamente correcto:

double x = 1.29;
double y = Math.floor(x * 100) / 100;
System.out.println(y);

Pero internamente, x * 100 puede representarse como 128.999999999....
Si floor devuelve 128, el resultado se convierte en 1.28.
Esto no es un error en Java, sino una propiedad de la aritmética de punto flotante.

Lo complicado es que esto ocurre solo ocasionalmente, lo que dificulta detectarlo durante las pruebas.

4.3 Truncar de forma segura con BigDecimal (Recomendado)

Si desea truncar en el n‑ésimo decimal de forma fiable, usar BigDecimal es la opción más segura.
BigDecimal maneja números en base 10 de forma exacta y se usa comúnmente en cálculos monetarios.

El patrón básico es:

import java.math.BigDecimal;
import java.math.RoundingMode;

BigDecimal x = new BigDecimal("1.239");
BigDecimal y = x.setScale(2, RoundingMode.DOWN); // truncate at 2 decimal places
System.out.println(y); // 1.23

Puntos clave:

• setScale(2, ...) mantiene dos decimales
• RoundingMode.DOWN especifica truncamiento hacia cero

Observe que DOWN de BigDecimal no es lo mismo que Math.floor().
Con números negativos, el comportamiento difiere, por lo que también podría necesitar considerar FLOOR (explicado más adelante).

Los errores comunes incluyen:

• Crear BigDecimal a partir de un double (introduciendo errores de precisión)
• Olvidar llamar a setScale
• Usar el modo de redondeo incorrecto y redondear accidentalmente al alza

En resumen, Math.floor puede ser suficiente solo para propósitos de visualización, pero para cálculos importantes, BigDecimal es la opción más segura.

En la siguiente sección, profundizaremos en el truncamiento con BigDecimal, incluyendo la forma correcta de crear instancias para código del mundo real.

5. Truncar con BigDecimal (Más seguro para finanzas, facturación y tarifas)

Si desea truncar decimales con máxima precisión, BigDecimal debería ser su primera opción en Java.
double es rápido pero propenso a errores de precisión, lo que a menudo causa problemas más adelante en cálculos de dinero, facturación, comisiones o tarifas.
BigDecimal maneja números decimales de una forma más cercana a las expectativas humanas, por lo que se usa ampliamente en código empresarial.

5.1 Conceptos básicos de BigDecimal: crear a partir de double es peligroso (Lo más importante)

Un error muy común con BigDecimal es cómo se crea.
Si pasa un double directamente, el error de precisión interno puede conservarse.

import java.math.BigDecimal;

BigDecimal a = new BigDecimal(0.1);
System.out.println(a); // May become something like 0.10000000000000000555...

Truncar o calcular con este valor a menudo conduce a discrepancias “misteriosas”.

Formas seguras de crear BigDecimal son:

(A) Crear a partir de una cadena (más explícito y seguro)

BigDecimal a = new BigDecimal("0.1");

(B) Usar BigDecimal.valueOf(double) (a menudo recomendado)

BigDecimal a = BigDecimal.valueOf(0.1);

Para principiantes, la regla más segura es: cuando tengas dudas, crea BigDecimal a partir de un String.

5.2 Truncar en n lugares decimales con RoundingMode.DOWN

Para truncar en el n-ésimo lugar decimal, usa setScale.

• setScale(2, ...) → mantener dos lugares decimales
• RoundingMode.DOWN → truncar hacia cero

  import java.math.BigDecimal;
  import java.math.RoundingMode;
  
  BigDecimal x = new BigDecimal("123.4567");
  BigDecimal y = x.setScale(2, RoundingMode.DOWN);
  
  System.out.println(y); // 123.45
  

Si quieres eliminar todos los decimales y obtener un valor similar a un entero, se aplica el mismo enfoque.

BigDecimal x = new BigDecimal("123.999");
BigDecimal y = x.setScale(0, RoundingMode.DOWN);

System.out.println(y); // 123

Un detalle importante: setScale cambia el valor en sí, no solo cómo se muestra.
Esto es una operación de cálculo, no de formateo.

5.3 Truncar hacia cero vs dirección de piso (Diferencia importante)

BigDecimal ofrece múltiples modos de redondeo, y hay dos que parecen “truncamiento”, lo que puede ser confuso.

• RoundingMode.DOWN : truncar hacia cero

  • 3.9 → 3
  • -3.9 → -3

  • RoundingMode.FLOOR : truncar hacia −∞ (piso matemático)

  • 3.9 → 3

  • -3.9 → -4

Si quieres que los valores siempre se muevan hacia el lado más pequeño en la recta numérica, FLOOR es la elección correcta.

import java.math.BigDecimal;
import java.math.RoundingMode;

BigDecimal x1 = new BigDecimal("-3.9");
System.out.println(x1.setScale(0, RoundingMode.DOWN));  // -3
System.out.println(x1.setScale(0, RoundingMode.FLOOR)); // -4

Cuál es “correcto” depende enteramente de tu caso de uso.

• Simplemente eliminar dígitos (truncar) → DOWN
• Truncamiento matemático (piso) → FLOOR

Si esta distinción no está clara, los valores negativos pueden causar errores graves de especificación.

5.4 Errores comunes con BigDecimal

Aquí hay errores frecuentes al truncar con BigDecimal:

• Crear BigDecimal a partir de double e introducir errores de precisión → Evita new BigDecimal(0.1) ; usa String o valueOf
• Usar la escala incorrecta → Por ejemplo, usar 0 en lugar de 2 lugares decimales
• Confundir los modos de redondeo → Confundir DOWN y FLOOR, causando problemas con números negativos
• Cambiar valores cuando solo querías formatear → setScale cambia el valor; separa el cálculo y la visualización

En resumen, para dinero, facturación o tasas—donde incluso una diferencia de un centavo importa—
usa BigDecimal y corrige tanto el método de creación como el modo de redondeo.

En la siguiente sección, explicaremos cómo evitar confundir el formateo de visualización y el truncamiento de cálculo.

6. DecimalFormat / String.format son solo para visualización (No uses para cálculos)

Al truncar decimales, es crucial distinguir si quieres truncar el valor calculado o solo formatear la visualización.
Mezclar estos dos lleva a situaciones donde la pantalla se ve correcta pero el valor interno está equivocado, causando errores más tarde.

La lección clave: DecimalFormat y String.format son solo para visualización.
Si necesitas truncar el valor real, usa BigDecimal o Math.floor().

6.1 Formatear lugares decimales con DecimalFormat (Truncamiento posible)

DecimalFormat es una clase para convertir números en cadenas formateadas.
Por ejemplo, se usa a menudo cuando quieres mostrar dos lugares decimales.

import java.text.DecimalFormat;

double x = 1.239;

DecimalFormat df = new DecimalFormat("0.00");
System.out.println(df.format(x)); // May become 1.24 (rounded)

Lo importante es que el valor de retorno de format() es un String,
y el valor numérico de x en sí no cambia.

También puedes especificar el modo de redondeo.
Para truncar la visualización, haz lo siguiente:

import java.text.DecimalFormat;
import java.math.RoundingMode;

double x = 1.239;

DecimalFormat df = new DecimalFormat("0.00");
df.setRoundingMode(RoundingMode.DOWN);

System.out.println(df.format(x)); // 1.23

However, this only changes the displayed string; the value of x remains unchanged.

6.2 Caveats When Using String.format

String.format also lets you control numeric output formatting.

double x = 1.239;
System.out.println(String.format("%.2f", x)); // A menudo redondea a 1.24

In many cases, String.format("%.2f", x) performs round half up behavior.
It’s usually unsuitable if you specifically want truncation.

A very common beginner mistake is converting a formatted string back into a number and using it in calculations.

double x = 1.239;
String s = String.format("%.2f", x); // "1.24"
double y = Double.parseDouble(s);    // 1.24

// En este punto, los cálculos usan un valor redondeado, no truncado

This mixes display concerns into calculation logic, making future changes harder.

6.3 Key Pitfall: Correct Display Does Not Mean Correct Values

The most dangerous assumption is “it looks correct on the screen, so it must be fine.”

• DecimalFormat / String.format change how values look
• Math.floor / BigDecimal.setScale change the actual value

If you confuse these, you may run into problems like:

• The UI shows “$1.23” but internal calculations still sum “$1.239”
• Rounding happens at the wrong stage, causing billing totals to differ
• Display rounding leaks into calculations, causing audit discrepancies

A simple rule of thumb:

• Only formatting for display → DecimalFormat (or UI formatting)
• Truncating as part of calculation → BigDecimal / Math.floor

In the next section, we’ll provide a quick reference table so you can instantly choose the right approach by use case.

7. Best Practices by Use Case (Quick Reference)

“Java decimal truncation” is confusing because there are multiple valid approaches.
Here, we fix the decision by mapping use case → best solution, so you can choose quickly.

7.1 Convert to int (Positive Numbers Only) → Casting Is Enough

If you just want to remove decimals and convert to int, and negative numbers will never appear, casting is the fastest option.

double x = 12.99;
int y = (int) x;
System.out.println(y); // 12

Things to remember:

• Casting rounds toward zero
• With positive values, it looks the same as truncation
• If negatives may appear, don’t lock in this approach

7.2 Truncate Including Negative Numbers → Math.floor

If you want mathematical truncation (floor), Math.floor() is the correct choice.
It’s safer than casting when negative numbers may occur.

double x = -3.9;
int y = (int) Math.floor(x);
System.out.println(y); // -4

Common notes:

• Math.floor() returns a double
• Cast to int or long if needed
• Watch out for int overflow with large values

7.3 Truncate at the n-th Decimal Place (Strict) → BigDecimal + setScale

If you want to truncate at a specific decimal place without precision errors, BigDecimal is the safest option.

import java.math.BigDecimal;
import java.math.RoundingMode;

BigDecimal x = new BigDecimal("1.239");
BigDecimal y = x.setScale(2, RoundingMode.DOWN);

System.out.println(y); // 1.23

This approach is ideal for:

• Money (JPY, USD, etc.)
• Billing and tax calculations
• Rate calculations where errors are unacceptable
• Batch jobs requiring deterministic results

Common pitfalls:

• Do not create BigDecimal from double (avoid new BigDecimal(0.1) )
• Understand the difference between DOWN and FLOOR (negative numbers)

7.4 Format for Display Only → DecimalFormat (Never for Calculation)

If you only want to format numbers for display (e.g., two decimals), DecimalFormat is convenient.
However, it does not change the underlying numeric value, so never use it for calculations.

import java.text.DecimalFormat;
import java.math.RoundingMode;

double x = 1.239;

DecimalFormat df = new DecimalFormat("0.00");
df.setRoundingMode(RoundingMode.DOWN);

System.out.println(df.format(x)); // "1.23"

Notas:

• El valor de retorno es un String
• Mezclar la lógica de presentación con los cálculos provoca errores

En una frase, la conclusión es:

• Rápido y sencillo → Casting
• Correcto con negativos → Math.floor
• Precisión primero (caso real) → BigDecimal
• Solo para mostrar → DecimalFormat

A continuación, resumiremos los errores más comunes y cómo evitarlos.

8. Errores Comunes y Advertencias Clave

El truncamiento de decimales a menudo “parece funcionar”, lo que facilita que los principiantes pasen por alto errores sutiles.
A continuación, errores reales y cómo evitarlos.

8.1 Malinterpretar Qué Significa “Truncar” (Hacia 0 vs Floor)

El error más frecuente es asumir que truncar siempre significa “ir a un número menor”.
En Java, el significado depende del método.

• Casting (int) : hacia cero

  • 3.9 → 3
  • -3.9 → -3

  • Math.floor() : hacia −∞

  • 3.9 → 3

  • -3.9 → -4

Si pueden aparecer valores negativos y utilizas casting, solo el lado negativo será incorrecto.
Esto suele pasar desapercibido si las pruebas solo usan valores positivos.

Contramedidas:

• Si pueden aparecer negativos, considera Math.floor() desde el principio
• Con BigDecimal, no confundas RoundingMode.DOWN y FLOOR

8.2 Resultados Inesperados Debido a la Precisión de double

Al implementar el truncamiento con Math.floor(x * 100) / 100, puedes observar discrepancias aun cuando la lógica parezca correcta.
La causa es la representación interna de double.

double x = 1.29;
double y = Math.floor(x * 100) / 100;
System.out.println(y);

Dependiendo del valor, x * 100 puede convertirse en 128.999999999..., lo que da como resultado 1.28.
Como esto no ocurre siempre, suele descubrirse en producción.

Contramedidas:

• Usa BigDecimal para dinero y facturación
• Si usas double, limítalo a casos donde los pequeños errores sean aceptables

8.3 Usar double para Cálculos Monetarios

Utilizar double para dinero suele producir:

• Totales que no coinciden después del truncamiento
• Pequeños errores de redondeo que se acumulan
• Desfase entre los valores mostrados y los internos

Contramedidas:

• Usa BigDecimal para valores monetarios
• Corrige el método de creación (String o valueOf )
• Documenta las reglas de redondeo explícitamente

8.4 Usar Formato de Presentación para Cálculos

Formatear con DecimalFormat o String.format y luego volver a convertir a números es peligroso.

double x = 1.239;
String s = String.format("%.2f", x); // display formatting
double y = Double.parseDouble(s);    // used in calculation (dangerous)

Esto provoca:

• El redondeo de presentación se filtra en los cálculos
• Cambios en la especificación que afectan la lógica
• Pérdida de la separación entre presentación y cálculo

Contramedidas:

• Finaliza los cálculos con BigDecimal o Math.floor()
• Formatea solo en la etapa final de visualización
• Mantén cálculo y presentación separados

9. Resumen: Conclusiones para Copiar‑Pegar

Existen varias formas de truncar decimales en Java, pero la vía más rápida es elegir según el caso de uso.
A continuación, conclusiones listas para usar.

9.1 Si No Estás Seguro, Usa Estas

Caso 1: Convertir a int (Solo Números Positivos)

double x = 12.99;
int y = (int) x;  // 12

Nota: Con números negativos, -3.9 → -3, por lo que no es el piso matemático.

Caso 2: Truncamiento Matemático Incluyendo Negativos

double x = -3.9;
int y = (int) Math.floor(x); // -4

Punto: Math.floor() trunca hacia −∞.

Caso 3: Truncar a n Decimales (double, simple)

*Usa solo cuando los pequeños errores de precisión sean aceptables.

double x = 1.239;
double y = Math.floor(x * 100) / 100; // 1.23

Advertencia: pueden aparecer problemas de precisión de double. Para una exactitud estricta, usa BigDecimal.

Caso 4: Truncar de forma fiable a n decimales (Recomendado)

import java.math.BigDecimal;
import java.math.RoundingMode;

BigDecimal x = new BigDecimal("1.239");
BigDecimal y = x.setScale(2, RoundingMode.DOWN); // 1.23

Puntos clave:

• No cree BigDecimal a partir de double
• Utilícelo para dinero, facturación y tarifas

Caso 5: Solo para visualización (Nunca para cálculo)

import java.text.DecimalFormat;
import java.math.RoundingMode;

double x = 1.239;

DecimalFormat df = new DecimalFormat("0.00");
df.setRoundingMode(RoundingMode.DOWN);

System.out.println(df.format(x)); // "1.23"

Nota: Esto produce una String; el valor numérico permanece sin cambios.

Preguntas frecuentes

Q1. ¿Cuál es la forma más fácil de truncar decimales en Java?

Respuesta: Si solo necesita un entero, el casting con (int) es el más rápido. Si pueden aparecer números negativos, considere Math.floor().

Q2. ¿Por qué (int) da resultados inesperados con números negativos?

Respuesta: El casting redondea hacia cero. Por ejemplo, -3.9 → -3. Para truncamiento matemático, use Math.floor().

Q3. ¿Cómo truncar a dos decimales (p. ej., 1.239 → 1.23)?

Respuesta: Para un enfoque sencillo, use Math.floor(x * 100) / 100. Para mayor precisión, use BigDecimal.setScale(2, RoundingMode.DOWN).

Q4. ¿Por qué Math.floor(x * 100) / 100 a veces produce valores incorrectos?

Respuesta: Esto se debe a errores de precisión de double. Para dinero o facturación, cambie a BigDecimal.

Q5. ¿Cuál es la forma correcta de truncar usando BigDecimal?

Respuesta: Cree BigDecimal a partir de una cadena o valueOf, luego use setScale(n, RoundingMode.DOWN). Evite new BigDecimal(double).

Q6. ¿Cuál es la diferencia entre RoundingMode.DOWN y FLOOR?

Respuesta: Difieren con números negativos. DOWN trunca hacia cero; FLOOR trunca hacia −∞. Elija según si desea truncar o aplicar el piso matemático.

Q7. ¿Puedo truncar decimales con DecimalFormat?

Respuesta: Puede truncar la visualización estableciendo un modo de redondeo, pero solo afecta la presentación. El valor interno no cambia.

Q8. ¿Cuándo debe aplicarse el truncamiento en los cálculos?

Respuesta: Depende de la especificación. Decida si truncar en cada paso o al final, documente la regla claramente y aplíquela de forma consistente—preferiblemente con BigDecimal.