Como Truncar Decimais em Java (cast para int, Math.floor, BigDecimal setScale)

1. O que Significa “Truncar Decimais” em Java?

Quando as pessoas dizem “truncar decimais” em Java, geralmente querem dizer remover a parte fracionária para obter um inteiro ou descartar dígitos após a n‑ésima casa decimal.
Na prática, porém, “truncar” pode ter mais de um sentido, então vamos esclarecer a conclusão primeiro.

1.1 “Truncar” significa floor? Ou cast? (Terminologia)

Existem basicamente dois padrões de “truncamento”.

• (A) Truncamento em direção a 0 (truncate) Remove a parte fracionária, mas para números negativos ele se move “mais próximo de zero”. Exemplos: 3.9 → 3 , -3.9 → -3 → Em Java, o cast para (int) se comporta assim
• (B) Truncamento em direção a −∞ (floor) Move para baixo (em direção a valores menores) na reta numérica Exemplos: 3.9 → 3 , -3.9 → -4 → Em Java, o Math.floor() se comporta assim

Iniciantes costumam se confundir porque para números positivos, (A) e (B) produzem o mesmo resultado.
Mas no momento em que você lida com números negativos, os resultados divergem.

1.2 O Que Este Artigo Ajuda Você a Fazer (Rota Mais Rápida por Caso de Uso)

Quem pesquisa “java truncate decimals” geralmente quer uma das seguintes coisas.

• Apenas converter para um inteiro (ex.: 3.14 → 3) → Cast com (int) é o mais rápido. Mas tome cuidado com números negativos.
• Truncar em 2 casas decimais (ex.: 1.239 → 1.23) → Math.floor(x * 100) / 100 pode funcionar → Mas se a precisão for importante, BigDecimal é mais seguro
• Dinheiro/faturamento/taxas onde erros são inaceitáveis → Use BigDecimal + setScale + RoundingMode

Se você escolher o método errado, ele costuma “parecer funcionar” mas falha depois.
Em particular, cálculos baseados em double podem introduzir erros de precisão, então para lógica financeira é mais seguro projetar com BigDecimal desde o início.

1.3 Armadilhas Comuns (Corrija Estas Primeiro)

Três erros frequentes são:

• Assumir que (int) sempre significa floor → Na verdade ele arredonda em direção a zero, então números negativos são diferentes.
• Usar Math.floor para truncar decimais, mas obter pequenos desvios → Muitas vezes causado pela precisão de double (depende dos valores/ambiente).
• Usar formatação (DecimalFormat, etc.) como se alterasse o valor computado → A exibição pode mudar enquanto o valor interno permanece o mesmo.

Primeiro confirme o caminho mais curto: “Se você só precisa de um inteiro, faça o cast.” Depois entenda a “armadilha dos números negativos”.

Na próxima seção, explicaremos truncamento via cast (int) com exemplos concretos.

2. Se Você Só Quer um int, o Cast Funciona (Mas Há um Detalhe)

Se você só quer remover a parte fracionária e obter um inteiro (int), a abordagem mais rápida em Java é o cast (conversão de tipo).
Mas o cast não é “truncamento matemático (floor)”. Ele arredonda em direção a zero (truncate), o que faz muita diferença.

2.1 Conceitos Básicos: Truncar a Parte Fracionária com (int)

Quando você converte um double ou float para int, a parte fracionária é descartada.

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

Esta é a resposta mais simples para a intenção comum “Quero truncar decimais”.

Os passos são:

• Confirmar que o valor é um double / float
• Adicionar (int) para fazer o cast para int
• Verificar o resultado — incluindo números negativos, se eles puderem ocorrer

2.2 Importante: Cast Arredonda em Direção a Zero (Números Negativos São Diferentes)

Esta é a armadilha nº 1 para iniciantes.
O cast nem sempre “desce para o valor menor”.

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

-3.9 tornando‑se -3 (não -4) acontece porque o cast converte na direção mais próxima de zero.

• 3.9 → 3 (em direção a zero)
• -3.9 → -3 (em direção a zero)

Se você quiser “truncamento matemático (floor)”, precisa usar Math.floor(), não o cast.
Se perder isso, pode gerar bugs em coisas como cálculos de P&L, taxas, ou matemática de coordenadas, onde apenas o lado negativo está errado.

2.3 Erros Comuns: Supor Arredondamento / Falhas com Números Negativos

Casting não é arredondamento para o mais próximo.
Se você pensa que “0,9 se torna 1”, estará errado.

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

Além disso, com números negativos pode parecer que o valor “aumentou” ou “diminuiu” inesperadamente.

• -3.9 → -3 move na direção maior na linha numérica
• Se você esperava -4, isso é um bug real

Correção é simples:

• Se você lida apenas com valores positivos → casting está ok
• Se valores negativos podem aparecer → considere Math.floor()
• Se precisão estrita for necessária (dinheiro, etc.) → considere BigDecimal

Na próxima seção, explicaremos Math.floor() / Math.ceil(), que permite truncar de forma matematicamente consistente mesmo para números negativos.

3. Use Math.floor / Math.ceil para Truncamento Decimal Correto

Se você deseja truncar decimais matematicamente corretos, a abordagem básica é usar Math.floor() em vez de casting.
Especialmente quando números negativos podem aparecer, simplesmente escolher Math.floor() reduz significativamente os bugs.

3.1 Truncamento com Math.floor() (Função Floor)

Math.floor() é chamada de função floor e arredonda valores para baixo (em direção a valores menores) na linha numérica.

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

Pontos chave:

• 3.9 → 3.0 (move para baixo)
• -3.9 → -4.0 (move ainda mais para baixo)

A maior vantagem é que o truncamento não se comporta de forma inesperada com números negativos.

Um erro comum é que Math.floor() retorna um double.
Se você precisar de um inteiro, deve convertê-lo depois.

3.2 Math.ceil() Arredonda Para Cima — Não Confunda

Math.ceil() é o oposto de Math.floor() e arredonda para cima (em direção a valores maiores) na linha numérica.

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

Um erro comum é:

• Pensar que “remover decimais” significa ceil → Na realidade, ceil arredonda para cima, o que costuma ser o oposto do que você deseja.

Se você pesquisou por “truncar decimais”, floor geralmente é a escolha correta.

3.3 Conversão de Tipo ao Converter para long / int

Se você quiser converter o resultado de Math.floor() para int ou long, precisa fazer casting.

double x = -3.9;

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

Pontos a observar:

• O resultado de Math.floor() é um double
• O casting para int remove a parte decimal (sem incompatibilidade nesta fase)
• Se o valor for muito grande, pode não caber em int

Para segurança, você pode escolher long primeiro.

double x = 12345678901.9;

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

Erros comuns incluem:

• Esquecer de fazer casting e deixar o valor como double
• Não entender a diferença entre floor e casting, causando bugs com negativos
• Overflow ao exceder o intervalo de int

Em resumo, se números negativos podem estar envolvidos, é mais seguro projetar usando Math.floor() desde o início.

Na próxima seção, explicaremos como truncar na n‑ésima casa decimal (por exemplo, mantendo duas casas) com exemplos concretos.

4. Como Truncar na n‑ésima Casa Decimal (Comum em Exibição & Cálculos)

Em aplicações reais, é muito comum querer manter até certa casa decimal e descartar o resto, não apenas remover todos os decimais.
Exemplos incluem alíquotas de impostos, taxas de câmbio, preços unitários e percentuais.

Aqui organizamos maneiras práticas de truncar na n‑ésima casa decimal.
Ao usar double, podem ocorrer problemas de precisão, então também abordaremos as armadilhas.

4.1 Padrão Básico: Multiplicar por 10^n, floor, depois dividir

1. Decida o número de casas decimais n
2. Multiplique por 10^n
3. Aplique Math.floor()
4. Divida por 10^n para restaurar a escala

Para truncar para 2 casas decimais (ex.: 1.239 → 1.23):

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

Para truncar para 3 casas decimais (ex.: 1.2399 → 1.239):

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

Vantagens desta abordagem:

• Código curto e fácil
• Usa Math.floor(), portanto o comportamento com números negativos é consistente
• Não requer bibliotecas adicionais

Entretanto, como isso depende de double, não é adequado para cálculos rigorosos como dinheiro.

4.2 Armadilha: Resultados Inesperados Devido à Precisão do double

O double do Java é um tipo ponto flutuante e nem sempre pode representar valores como 0.1 ou 0.01 exatamente.
Como resultado, você pode observar discrepâncias aparentemente “sem sentido” (dependendo dos valores e do ambiente).

• Você espera 1.29, mas ele aparece como 1.28
• Você manipula 0.3, mas internamente ele é 0.299999999...

Por exemplo, o código a seguir parece logicamente correto:

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

Mas internamente, x * 100 pode ser representado como 128.999999999....
Se floor retornar 128, o resultado se torna 1.28.
Isso não é um bug no Java, mas uma propriedade da aritmética de ponto flutuante.

A parte complicada é que isso ocorre apenas ocasionalmente, o que dificulta a detecção durante os testes.

4.3 Truncar com Segurança usando BigDecimal (Recomendado)

Se você deseja truncar na n‑ésima casa decimal de forma confiável, usar BigDecimal é a escolha mais segura.
BigDecimal lida com números base‑10 exatamente e é comumente usado em cálculos monetários.

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

Pontos principais:

• setScale(2, ...) mantém duas casas decimais
• RoundingMode.DOWN especifica truncamento em direção a zero

Observe que o DOWN do BigDecimal não é o mesmo que Math.floor().
Com números negativos, o comportamento difere, portanto você pode precisar considerar FLOOR (explicado mais adiante).

Erros comuns incluem:

• Criar BigDecimal a partir de um double (introduzindo erros de precisão)
• Esquecer de chamar setScale
• Usar o modo de arredondamento errado e acabar arredondando half‑up

Em resumo, Math.floor pode ser suficiente para fins de exibição, mas para cálculos importantes, BigDecimal é a escolha mais segura.

Na próxima seção, aprofundaremos a truncagem com BigDecimal, incluindo a forma correta de criar instâncias para código em produção.

5. Truncando com BigDecimal (Mais Seguro para Finanças, Faturamento e Taxas)

Se você deseja truncar decimais com máxima precisão, BigDecimal deve ser sua primeira escolha em Java.
double é rápido, mas propenso a erros de precisão, o que frequentemente causa problemas posteriores em cálculos de dinheiro, faturamento, taxas ou tarifas.
BigDecimal lida com números decimais de forma mais próxima das expectativas humanas, sendo amplamente usado em código empresarial.

5.1 Conceitos Básicos de BigDecimal: Criar a partir de double é Perigoso (Mais Importante)

Um erro muito comum com BigDecimal é como ele é criado.
Se você passar um double diretamente, o erro interno de precisão pode ser mantido.

import java.math.BigDecimal;

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

Truncar ou calcular com esse valor frequentemente leva a discrepâncias “misteriosas”.

Formas seguras de criar BigDecimal são:

(A) Criar a partir de uma String (mais explícito e seguro)

BigDecimal a = new BigDecimal("0.1");

(B) Usar BigDecimal.valueOf(double) (frequentemente recomendado)

BigDecimal a = BigDecimal.valueOf(0.1);

Para iniciantes, a regra mais segura é: quando houver dúvida, crie BigDecimal a partir de uma String.

5.2 Truncar em n casas decimais com RoundingMode.DOWN

Para truncar na n‑ésima casa decimal, use setScale.

• setScale(2, ...) → manter duas casas decimais
• RoundingMode.DOWN → truncar em direção a zero

  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
  

Se você quiser descartar todas as casas decimais e obter um valor semelhante a um inteiro, a mesma abordagem se aplica.

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

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

Um detalhe importante: setScale altera o próprio valor, não apenas a forma como ele é exibido.
Isso é uma operação de cálculo, não de formatação.

5.3 Truncar em direção a zero vs direção de floor (Diferença importante)

BigDecimal oferece múltiplos modos de arredondamento, e há dois que parecem “truncamento”, o que pode ser confuso.

• RoundingMode.DOWN : truncar em direção a zero

  • 3.9 → 3
  • -3.9 → -3

  • RoundingMode.FLOOR : truncar em direção a −∞ (floor matemático)

  • 3.9 → 3

  • -3.9 → -4

Se você quiser que os valores sempre se movam para o lado menor na reta numérica, FLOOR é a escolha correta.

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

Qual deles é “correto” depende totalmente do seu caso de uso.

• Simplesmente descartando dígitos (truncar) → DOWN
• Truncamento matemático (floor) → FLOOR

Se essa distinção não estiver clara, valores negativos podem causar bugs sérios de especificação.

5.4 Erros comuns com BigDecimal

Aqui estão erros frequentes ao truncar com BigDecimal:

• Criar BigDecimal a partir de double e introduzir erros de precisão → Evite new BigDecimal(0.1) ; use String ou valueOf
• Usar a escala errada → Por exemplo, usar 0 em vez de 2 casas decimais
• Confundir modos de arredondamento → Confundir DOWN e FLOOR, causando problemas com números negativos
• Alterar valores quando você só pretendia formatar → setScale altera o valor; separe cálculo e exibição

Em resumo, para dinheiro, faturamento ou taxas — onde até uma diferença de um centavo importa —
use BigDecimal e corrija tanto o método de criação quanto o modo de arredondamento.

Na próxima seção, explicaremos como evitar confundir formatação de exibição e truncamento de cálculo.

6. DecimalFormat / String.format são apenas para exibição (Não use para cálculos)

Ao truncar decimais, é crucial distinguir se você quer truncar o valor calculado ou apenas formatar a exibição.
Misturar esses dois leva a situações onde a tela parece correta, mas o valor interno está errado, causando bugs posteriormente.

O ponto principal: DecimalFormat e String.format são apenas para exibição.
Se precisar truncar o valor real, use BigDecimal ou Math.floor().

6.1 Formatando casas decimais com DecimalFormat (Truncamento possível)

DecimalFormat é uma classe para converter números em strings formatadas.
Por exemplo, costuma ser usada quando você quer exibir duas casas decimais.

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)

O importante é que o valor retornado por format() é uma String,
e o valor numérico de x em si não muda.

Você também pode especificar o modo de arredondamento.
Para truncar a exibição, faça o seguinte:

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)); // Frequentemente arredonda para 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

// Neste ponto, os cálculos usam um valor arredondado, não 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:

• O valor de retorno é uma String
• Misturar lógica de exibição em cálculos causa bugs

Em uma frase, o resumo é:

• Rápido & simples → Casting
• Correto com negativos → Math.floor
• Precisão em primeiro lugar (mundo real) → BigDecimal
• Apenas exibição → DecimalFormat

Em seguida, resumiremos os erros mais comuns e como evitá-los.

8. Erros Comuns e Avisos Importantes

A truncagem decimal frequentemente “parece funcionar”, tornando fácil para iniciantes perderem bugs sutis.
Aqui estão erros do mundo real e como evitá-los.

8.1 Entendendo Mal o Que “Truncar” Significa (Rumo a 0 vs Floor)

O erro mais comum é assumir que truncar sempre significa “ficar menor.”
Em Java, o significado depende do método.

• Casting (int) : rumo a zero

  • 3.9 → 3
  • -3.9 → -3

  • Math.floor() : rumo a −∞

  • 3.9 → 3

  • -3.9 → -4

Se valores negativos forem possíveis e você usar casting, apenas o lado negativo estará errado.
Isso frequentemente passa despercebido se os testes usarem apenas valores positivos.

Contramedidas:

• Se negativos puderem aparecer, considere Math.floor() desde o início
• Com BigDecimal, não confunda RoundingMode.DOWN e FLOOR

8.2 Resultados Inesperados Devido à Precisão do double

Ao implementar truncagem com Math.floor(x * 100) / 100, você pode ver discrepâncias mesmo se a lógica parecer correta.
A causa é a representação interna do double.

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

Dependendo do valor, x * 100 pode se tornar 128.999999999..., resultando em 1.28.
Como isso não acontece toda vez, é frequentemente descoberto em produção.

Contramedidas:

• Use BigDecimal para dinheiro e faturamento
• Se usando double, restrinja o uso a casos onde pequenos erros são aceitáveis

8.3 Usando double para Cálculos de Dinheiro

Usar double para dinheiro frequentemente leva a:

• Totais não correspondendo após a truncagem
• Pequenos erros de arredondamento se acumulando
• Discrepância entre valores exibidos e internos

Contramedidas:

• Use BigDecimal para valores monetários
• Corrija o método de criação (String ou valueOf )
• Documente regras de arredondamento explicitamente

8.4 Usando Formatação de Exibição para Cálculos

Formatar com DecimalFormat ou String.format e depois analisar de volta para números é perigoso.

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

Isso causa:

• Arredondamento de exibição vazando para cálculos
• Mudanças de especificação afetando a lógica
• Perda de separação entre exibição e cálculo

Contramedidas:

• Finalize cálculos com BigDecimal ou Math.floor()
• Formate apenas na etapa final de exibição
• Mantenha cálculo e apresentação separados

9. Resumo: Conclusões Prontas para Copiar e Colar

Existem várias maneiras de truncar decimais em Java, mas o caminho mais rápido é escolher pelo caso de uso.
Aqui estão conclusões prontas para uso.

9.1 Se Você Não Tem Certeza, Use Estas

Caso 1: Converter para int (Apenas Números Positivos)

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

Nota: Com números negativos, -3.9 → -3, então isso não é floor matemático.

Caso 2: Truncagem Matemática Incluindo Negativos

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

Ponto: Math.floor() trunca rumo a −∞.

Caso 3: Truncar em n Casas Decimais (double, simples)

*Use apenas quando pequenos erros de precisão forem aceitáveis.

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

Aviso: Problemas de precisão do double podem ocorrer. Para precisão estrita, use BigDecimal.

.#### Caso 4: Truncar Confiavelmente em n Casas Decimais (Recomendado)

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

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

Pontos principais:

• Não crie BigDecimal a partir de double
• Use isso para dinheiro, faturamento e taxas

Caso 5: Apenas Exibição (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"

Ponto: Isso produz uma String; o valor numérico permanece inalterado.

Perguntas Frequentes

Q1. Qual é a maneira mais fácil de truncar decimais em Java?

Resposta: Se você só precisa de um inteiro, fazer cast com (int) é o mais rápido. Se números negativos podem aparecer, considere Math.floor().

Q2. Por que (int) dá resultados inesperados para números negativos?

Resposta: O cast arredonda em direção a zero. Por exemplo, -3.9 → -3. Para truncamento matemático, use Math.floor().

Q3. Como truncar para duas casas decimais (por exemplo, 1.239 → 1.23)?

Resposta: Para uma abordagem simples, use Math.floor(x * 100) / 100. Para precisão rigorosa, use BigDecimal.setScale(2, RoundingMode.DOWN).

Q4. Por que Math.floor(x * 100) / 100 às vezes produz valores errados?

Resposta: Isso ocorre devido a erros de precisão de double. Para dinheiro ou faturamento, troque para BigDecimal.

Q5. Qual é a maneira correta de truncar usando BigDecimal?

Resposta: Crie BigDecimal a partir de uma String ou valueOf, então use setScale(n, RoundingMode.DOWN). Evite new BigDecimal(double).

Q6. Qual é a diferença entre RoundingMode.DOWN e FLOOR?

Resposta: Eles diferem para números negativos. DOWN trunca em direção a zero; FLOOR trunca em direção a −∞. Escolha com base em se você quer truncar ou o piso matemático.

Q7. Posso truncar decimais com DecimalFormat?

Resposta: Você pode truncar a exibição definindo um modo de arredondamento, mas isso é apenas para exibição. O valor interno não muda.

Q8. Quando a truncagem deve ser aplicada nos cálculos?

Resposta: Depende da especificação. Decida se deve truncar a cada passo ou ao final, documente a regra claramente e implemente de forma consistente — preferencialmente com BigDecimal.