Deep Java

Como Arredondar Números em Java: Math.round(), Casas Decimais, BigDecimal e RoundingMode

Fundamentos de Java
目次

1. O que significa “Arredondamento (四捨五入)” em Java

Quando você quiser fazer “arredondamento (四捨五入)” em Java, na verdade não há um único método que sempre arredonde da maneira que você espera.
Isso porque em Java, a abordagem de arredondamento apropriada depende do tipo numérico (int / double / BigDecimal, etc.) e do objetivo (cálculo vs exibição).

Nesta seção, organizaremos primeiro os conceitos principais e esclareceremos por que o arredondamento em Java pode parecer confuso.

1.1 Regra Básica de Arredondamento (5 ou Mais Arredonda para Cima)

A regra geral de arredondamento é a seguinte:

  • Se o próximo dígito for 5 ou maior → arredondar para cima
  • Se o próximo dígito for 4 ou menor → arredondar para baixo

Exemplo (arredondando para a casa das unidades)

  • 1.4 → 1
  • 1.5 → 2

Essa regra é a mesma em Java, mas o verdadeiro desafio é “qual método aplica essa regra” e “quantos dígitos você pode lidar”.

Em Java, o arredondamento é tipicamente separado por propósito, como:

  • Você só quer arredondar um número simples
  • Você quer arredondar para o n-ésimo lugar decimal
  • Você precisa de tolerância zero para erros (por exemplo, cálculos de dinheiro)

Se você tentar lidar com todos esses com a mesma abordagem, frequentemente obterá resultados indesejados.

1.2 Por Que o Arredondamento em Java Pode Ser Confuso

As principais razões pelas quais o arredondamento em Java é frequentemente descrito como “difícil” ou “não funcionando como esperado” são estes três pontos:

Razão 1: Erros de precisão em ponto flutuante (double)

double é um tipo que representa decimais em binário.
Como resultado, mesmo números que parecem limpos em decimal podem incluir erros de precisão internos.

Exemplo:

double x = 0.1 + 0.2;
System.out.println(x); // 0.30000000000000004

Se você arredondar nesse estado, pode obter resultados que não correspondem à intuição humana.

Razão 2: Você não pode “arredondar diretamente para o n-ésimo lugar decimal”

Java não fornece um método dedicado como:
“arredondar para 2 casas decimais”
pronto para uso.

Então, em muitos casos, você precisa de um ajuste usando aritmética, como:

  • Multiplicar por 10 ou 100
  • Arredondar
  • Redimensionar de volta à magnitude original

Se você errar os passos, o resultado ficará incorreto.

Razão 3: Os métodos diferem em comportamento e tipos de retorno

Por exemplo, Math.round() é conveniente, mas ele retorna um tipo inteiro (int / long).
Se você quiser arredondar mantendo casas decimais, não pode usá-lo como está.

Armadilhas Comuns e Coisas a Observar

  • Assumir “arredondamento = Math.round()” → Frequentemente insuficiente para 2+ casas decimais ou cálculos de dinheiro
  • Fazer cálculos de dinheiro com double e arredondar depois → Erros podem se acumular e se tornar arriscados em sistemas do mundo real
  • Usar o mesmo arredondamento para exibição e cálculo → Você pode perder precisão ao arredondar cálculos internos

O arredondamento é um processo para “limpar a saída final”, e o momento e o tipo de dados ao qual você o aplica são extremamente importantes.

2. Arredondamento com Math.round() (A Abordagem Mais Básica)

Math.round() é um dos métodos mais básicos e fáceis para arredondamento em Java.
É uma boa abordagem inicial para iniciantes, mas você precisa entender seus casos de uso válidos e limitações para evitar mau uso.

Nesta seção, organizaremos o uso correto de Math.round() e as armadilhas comuns que você provavelmente encontrará no desenvolvimento real.

2.1 Uso Básico de Math.round()

Math.round() arredonda o número dado para o inteiro mais próximo.

double a = 1.4;
double b = 1.5;

System.out.println(Math.round(a)); // 1
System.out.println(Math.round(b)); // 2

Pontos principais:

  • Arredonda para cima quando a parte fracionária é 0.5 ou maior
  • Arredonda para baixo quando é menor que 0.5
  • Segue a regra padrão de round-half-up

Parece intuitivo, mas o tipo de retorno é um ponto importante a observar.

2.2 Cuidado: O Tipo de Retorno É int / long

Math.round() altera seu tipo de retorno dependendo do tipo do argumento.

Argument typeReturn type
floatint
doublelong

Exemplo:

double x = 3.7;
long result = Math.round(x);

O ponto principal é: o valor de retorno é sempre um tipo inteiro.

Em outras palavras, não é adequado “como está” para casos como:

  • Você quer manter decimais no resultado
  • Você quer manter 1 ou 2 casas decimais

porque o próprio Math.round() produz um inteiro.

Exemplo de Erro Comum

double price = 12.34;
double rounded = Math.round(price); // actually long → assigned to double

Esse código não gera erro de compilação, mas
a parte fracionária é totalmente perdida e se torna 12.0, então tenha cuidado.

2.3 Como Arredondar para a 2ª Casa Decimal ou Mais (Técnica ×10 / ×100)

Se você quiser usar Math.round() para arredondar para a n‑ésima casa decimal,
geralmente segue este processo:

Etapas

  1. Multiplique o valor alvo por 10ⁿ
  2. Arredonde para um inteiro com Math.round()
  3. Divida por 10ⁿ para retornar à escala original

Exemplo: Arredondar para 2 Casas Decimais

double value = 1.234;
double rounded = Math.round(value * 100) / 100.0;

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

Exemplo: Arredondar para 1 Casa Decimal

double value = 1.25;
double rounded = Math.round(value * 10) / 10.0;

System.out.println(rounded); // 1.3

Essa abordagem é simples, mas não elimina completamente problemas de precisão específicos de double.

Armadilhas, Avisos e Erros Comuns

  • Acidentalmente fazer divisão inteira Math.round(value * 100) / 100; // 100 é int → decimais desaparecem → Sempre use um double como 100.0
  • Usá‑lo diretamente para cálculos monetários → OK para exibição, mas frequentemente inadequado para cálculos
  • Arredondar muito cedo → Se você arredondar resultados intermediários, o valor final pode desviar

Math.round() é ótimo quando você “quer apenas um inteiro” ou “quer arredondar para exibição”, mas é preciso lembrar que
ele tem limitações quando a precisão é crítica.

3. Uma Forma Comum de Arredondar para a N‑ésima Casa Decimal

Solicitações como “quero arredondar para 2 casas decimais” ou “quero manter 3 casas decimais” são extremamente comuns, e
essa também é a intenção de busca principal por trás da palavra‑chave java 四捨五入.

Nesta seção, explicaremos uma abordagem comum para arredondar para a n‑ésima casa decimal usando Math.round(),
e apontaremos claramente suas limitações.

3.1 O Padrão de Fórmula Básica

Como o Java não fornece um método dedicado para arredondar para a n‑ésima casa decimal,
uma abordagem amplamente usada é escalar o número, arredondá‑lo e depois reescalá‑lo.

Fórmula básica

Math.round(value × 10^n) ÷ 10^n

Exemplo: Arredondar para 2 casas decimais

double value = 12.345;
double rounded = Math.round(value * 100) / 100.0;

System.out.println(rounded); // 12.35

Exemplo: Arredondar para 3 casas decimais

double value = 12.34567;
double rounded = Math.round(value * 1000) / 1000.0;

System.out.println(rounded); // 12.346

Esse método é fácil de entender e é prático o suficiente para processamento de números apenas para exibição.

3.2 Um Caso em que Não Funciona Bem (O Problema 0.1 + 0.2)

Entretanto, esse método não consegue evitar completamente erros de precisão de double.

Um exemplo clássico é o caso a seguir:

double value = 0.1 + 0.2;
double rounded = Math.round(value * 10) / 10.0;

System.out.println(value);   // 0.30000000000000004
System.out.println(rounded); // 0.3

Pode parecer correto aqui, mas dependendo do cálculo e do número de dígitos, ainda é possível obter resultados de arredondamento inesperados.

Os casos a seguir são especialmente arriscados:

  • Cálculos monetários
  • Cálculos cumulativos de alíquotas ou percentuais
  • Arredondamento repetido dentro de loops

3.3 Por que os Erros Ocorrem (Explicação Muito Breve)

double é um tipo de ponto flutuante que representa decimais em binário.
Portanto, mesmo valores que são exatos em base‑10 podem incluir pequenos erros em sua representação interna.

Isso é um detalhe da especificação do Java, não um bug.

Mal‑entendidos comuns

  • “Minha fórmula está errada” → ❌
  • “Java está quebrado” → ❌
  • “É devido à natureza do double” → ✅

Armadilhas, Avisos e Erros Comuns

  • Errar a ordem de escala/divisão Math.round(value) * 100 / 100.0; // sem sentido
  • Usar um inteiro na divisão Math.round(value * 100) / 100; // decimais desaparecem
  • Arredondar repetidamente em etapas intermediárias → faz com que os erros se acumulem mais facilmente

Este método é “fácil e rápido”, mas você deve entender que ele pode ser insuficiente quando a precisão é exigida.

4. Arredondamento Preciso com BigDecimal (Recomendado)

Para cálculos monetários, cálculos de impostos e outros fluxos de trabalho onde erros não são aceitáveis, arredondar com double e Math.round() não é adequado.

Nesses casos, a abordagem recomendada é usar BigDecimal.
BigDecimal é uma classe que pode lidar com números base‑10 de forma precisa, e é a solução padrão em Java para “arredondamento preciso”.

4.1 Quando Você Deve Usar BigDecimal

Você deve usar BigDecimal para casos como estes:

  • Cálculos monetários (preços, faturas, saldos)
  • Cálculos baseados em taxas, como alíquotas de impostos e juros
  • Contabilidade, finanças e sistemas empresariais
  • Processos onde os resultados do arredondamento precisam ser reproduzíveis

Se o resultado do cálculo em si importa (não apenas a exibição), é mais seguro escolher BigDecimal em vez de double.

4.2 A Forma Correta de Criar BigDecimal (new vs valueOf)

A armadilha mais comum com BigDecimal é criá‑lo da maneira errada.

❌ Exemplo Incorreto (não recomendado)

BigDecimal bd = new BigDecimal(1.23);

Isso transfere o erro de precisão do double.

✅ Exemplos Corretos (recomendado)

BigDecimal bd1 = new BigDecimal("1.23");
BigDecimal bd2 = BigDecimal.valueOf(1.23);
  • Construtor a partir de String: opção mais segura
  • valueOf : seguro porque converte internamente via String

Regra prática: evite new BigDecimal(double).

4.3 Como Usar setScale() e RoundingMode

Para arredondar com BigDecimal, normalmente combina‑se
setScale() com RoundingMode.

Exemplo: Arredondar para 2 casas decimais

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

BigDecimal value = new BigDecimal("12.345");
BigDecimal rounded = value.setScale(2, RoundingMode.HALF_UP);

System.out.println(rounded); // 12.35
  • 1º argumento: número de casas decimais a manter
  • 2º argumento: regra de arredondamento

RoundingMode.HALF_UP corresponde à regra típica de “arredondar metade para cima” (5 ou mais arredonda para cima).

Armadilhas, Avisos e Erros Comuns

  • Não especificar RoundingMode value.setScale(2); // pode lançar uma exceção
  • Fazer double → BigDecimal → arredondamento na ordem errada → use BigDecimal desde o início
  • Confundir exibição com cálculo → use BigDecimal para cálculo; formate apenas na exibição

BigDecimal adiciona mais código, mas é essencial sempre que precisão e segurança são as maiores prioridades.

5. Tipos de RoundingMode e Diferenças

Ao arredondar com BigDecimal, o conceito chave que você deve entender é RoundingMode (modo de arredondamento).

RoundingMode define explicitamente “qual regra usar”, e na prática deve ser considerado obrigatório, porque não especificá‑lo torna o comportamento ambíguo.

5.1 HALF_UP (Arredondamento Típico)

RoundingMode.HALF_UP corresponde à definição mais comum de arredondamento.

Regra

  • Se o próximo dígito for 5 ou maior → arredonda para cima
  • Se o próximo dígito for 4 ou menor → arredonda para baixo

Exemplo

BigDecimal value = new BigDecimal("2.345");
BigDecimal rounded = value.setScale(2, RoundingMode.HALF_UP);

System.out.println(rounded); // 2.35

Se você não tem um motivo especial, escolher HALF_UP para arredondamento costuma ser a escolha correta.

5.2 Como Difere de HALF_DOWN / HALF_EVEN

RoundingMode inclui vários estilos de arredondamento com nomes semelhantes.
Muitas pessoas se confundem aqui, então vamos esclarecer as diferenças.

HALF_DOWN

  • Se o próximo dígito for exatamente 5, arredonde para baixo
    2.345 → 2.34

HALF_EVEN (Arredondamento dos Bancos)

  • Se o próximo dígito for exatamente 5, arredonde para o número par mais próximo
    2.345 → 2.34
2.355 → 2.36

HALF_EVEN é usado para reduzir o viés sistemático de arredondamento e pode ser especificado em padrões de finanças ou estatísticas, mas é desnecessário para a maioria dos casos de negócios gerais e código amigável para iniciantes.

5.3 Como Escolher

Se você não tiver certeza, a regra de decisão é direta:

  • Arredondamento típico → HALF_UP
  • Domínio financeiro/regulado com um padrão definido → siga a especificação
  • Sem motivo especial → apenas HALF_UP

Erros comuns

  • “Usar HALF_EVEN só porque”
  • “Copiar e colar sem entender a diferença”

Os modos de arredondamento são parte da especificação do seu sistema.
Você não deve alterá-los sem um motivo claro.

Armadilhas, Avisos e Erros Comuns

  • Omitir RoundingMode → pode causar exceções em tempo de execução
  • Assumir que arredondamento sempre significa HALF_UP → pode conflitar com especificações de negócios
  • Regras de arredondamento não padronizadas na equipe → pode levar a resultados de cálculo inconsistentes

6. Armadilhas Comuns, Avisos e Exemplos de Falhas

O arredondamento em Java é uma área onde é fácil cometer erros mesmo se você souber a sintaxe e as APIs.
Nesta seção, resumiremos os erros que desenvolvedores iniciantes a intermediários comumente cometem, e explicaremos claramente “por que está errado” e “como evitar”.

6.1 Fazer cálculos de dinheiro com double

Este é o erro mais comum e o mais perigoso.

double price = 1000.0;
double tax = price * 0.1;
double total = price + tax;

Pode parecer bom à primeira vista, mas
como double é um tipo que pode incluir erros de precisão,
introduz o risco de resultados incorretos em cálculos de dinheiro.

Mentalidade correta

  • Para cálculo: BigDecimal
  • Para exibição: arredondamento/formatação
    BigDecimal price = new BigDecimal("1000");
BigDecimal tax = price.multiply(new BigDecimal("0.1"));
BigDecimal total = price.add(tax);

6.2 Errar a ordem de arredondamento

Com arredondamento, quando você o aplica importa.

❌ Exemplo ruim

double a = Math.round(x * 100) / 100.0;
double b = Math.round(a * y * 100) / 100.0;

Se você arredondar repetidamente durante etapas intermediárias, os erros se acumulam.

✅ Diretriz básica

  • Complete todos os cálculos primeiro
  • Aplique arredondamento apenas uma vez ao resultado final

6.3 Misturar arredondamento de exibição com arredondamento de cálculo

Se você confundir “arredondamento para exibição” com “arredondamento para cálculos internos”, seu design quebrará.

Mal-entendidos comuns

  • Usar um valor arredondado para exibição no próximo cálculo
  • Alterar a lógica de cálculo para corresponder aos requisitos de UI

Separação correta

  • Cálculo interno : priorize precisão (BigDecimal)
  • Exibição : formatação/arredondamento

6.4 Não padronizar RoundingMode

Se diferentes partes do seu código usarem uma mistura de
HALF_UP, HALF_DOWN e HALF_EVEN,
você pode acabar com resultados inconsistentes do mesmo cálculo.

Contramedidas

  • Defina a regra de arredondamento como uma constante
  • Padronize-a em toda a equipe/projeto
    static final RoundingMode ROUND_MODE = RoundingMode.HALF_UP;

Resumo de Armadilhas Comuns

  • Apenas porque double “pode calcular” não significa que é “preciso”
  • Arredonde apenas uma vez, no final
  • Trate as regras de arredondamento como parte da sua especificação
  • Separe cálculo e exibição

Manter isso em mente ajuda você a evitar a maioria dos problemas relacionados ao arredondamento.

7. Referência Rápida: Qual Método Usar (Por Caso de Uso)

Como explicado até agora, o Java tem várias maneiras de arredondar números, e o ponto chave não é “qual é o correto”, mas que
a escolha correta depende do caso de uso.

Nesta seção, organizaremos a seleção prática de métodos por cenário para que os leitores possam decidir rapidamente.

7.1 Se Você Quiser um Inteiro Simples → Math.round()

Casos de uso típicos

  • Você quer exibir um valor computado como um inteiro
  • Contagens, número de pessoas, pontos de classificação, etc.
  • Processamento onde erros de precisão não são um problema

Abordagem recomendada

long result = Math.round(value);

Notas

  • O tipo de retorno é int ou long
  • Não adequado se você precisar manter decimais

👉 Se você “só quiser um inteiro”, use Math.round().

7.2 Se Você Quiser Exibir Até N Casas Decimais → Math.round() + Escala

Casos de uso típicos

  • Números para exibição na UI
  • Relatórios e saída de logs
  • Casos onde precisão estrita não é necessária

Abordagem recomendada (2 casas decimais)

double rounded = Math.round(value * 100) / 100.0;

Notas

  • Erros de precisão do double ainda permanecem
  • Não use para dados de cálculo

👉 Aceitável apenas para exibição

7.3 Dinheiro, Impostos, Lógica de Negócios → BigDecimal + HALF_UP

Casos de uso típicos

  • Dinheiro, faturamento, pagamentos
  • Taxas de imposto e taxas de desconto
  • Lógica de negócios e dados persistidos

Abordagem recomendada

BigDecimal rounded =
    value.setScale(2, RoundingMode.HALF_UP);

Por quê

  • Lida com números base-10 com precisão
  • Torna as regras de arredondamento explícitas
  • Garante reprodutibilidade

👉 Esta é efetivamente a abordagem padrão em sistemas do mundo real

7.4 Um Fluxo de Decisão Simples Quando Você Estiver Incerto

  • “Algum erro é aceitável?” wp:list /wp:list

    • SIM → abordagens baseadas em Math.round()
    • NÃO → BigDecimal

    • “Você vai salvar/reutilizar o resultado?” wp:list /wp:list

    • SIM → BigDecimal

    • NÃO (apenas exibição) → Math.round()

Erros Comuns (Seleção de Método)

  • Reutilizar código apenas para exibição na lógica de negócios
  • Continuar usando double para valores monetários
  • Usar excessivamente Math.round() “porque é fácil”

Uma vez que você organize a seleção de métodos, você pode reduzir significativamente o custo de mudanças futuras de especificação e correções de bugs.

FAQ (Perguntas Frequentes)

Q1. Qual é a maneira mais fácil de arredondar no Java?

A. Se você simplesmente quiser arredondar para um inteiro, Math.round() é o mais fácil. No entanto, o tipo de retorno é um inteiro, então você não pode manter decimais.

Q2. Como eu arredondo para 2 casas decimais (ou a enésima casa decimal)?

A. Para fins de exibição, escale o número como:
Math.round(value * 100) / 100.0
Se você precisar de precisão, use BigDecimal.setScale().

Q3. Por que os resultados desviam mesmo que eu esteja usando Math.round()?

A. Isso é causado por erros de precisão de ponto flutuante em double. É parte do comportamento do Java, não um bug.

Q4. Eu devo evitar Math.round() para cálculos de dinheiro?

A. Sim, não é recomendado. Para cálculos de dinheiro e impostos, é mais seguro usar BigDecimal e arredondar com RoundingMode.HALF_UP.

Q5. Estou usando BigDecimal mas ainda vejo erros às vezes

A. Você pode estar usando new BigDecimal(double).
Use new BigDecimal("1.23") ou BigDecimal.valueOf(1.23) em vez disso.

Q6. Qual RoundingMode eu devo escolher?

A. Para arredondamento típico, RoundingMode.HALF_UP é um padrão seguro. Se o seu domínio tiver um padrão/especificação definida, siga-o.

Q7. É aceitável arredondar durante cálculos intermediários?

A. Não recomendado. Arredondar durante etapas intermediárias faz com que os erros se acumulem, então a regra básica é aplicá-lo apenas ao resultado final.

Q8. Eu devo separar o arredondamento para exibição vs arredondamento para cálculos?

A. Sim.

  • Para cálculos: BigDecimal (precisão em primeiro lugar)
  • Para exibição: Math.round() ou formatação Separar eles é o design correto.