Arredondamento e formatação de números

1. Introdução

No dia a dia, raramente precisamos ver longas casas decimais após a vírgula. Por exemplo, se você calcula o preço de um produto, um salário, a média ou a área de um cômodo — normalmente bastam duas casas decimais, e não 15.

Por exemplo, o resultado da divisão:

double x = 10.0 / 3.0;
System.out.println(x); // 3.3333333333333335

O usuário, ao ver esse resultado, pode se assustar e pensar que o programa enlouqueceu. Por isso, muitas vezes é preciso arredondar números — para o inteiro mais próximo, para duas casas decimais e assim por diante.

Em Java há várias ferramentas convenientes para isso.

2. Método Math.round(): arredondamento para o inteiro mais próximo

A maneira mais simples de arredondar um número é usar o método Math.round(). Ele aceita um número de ponto flutuante (pode ser float ou double) e retorna o inteiro mais próximo.

Como o Math.round funciona

• Se a parte fracionária for menor que 0.5 — arredonda para baixo.
• Se a parte fracionária for 0.5 ou maior — arredonda para cima.

Exemplos:

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 do valor retornado

• Se você passar float, retorna int.
• Se você passar double, retorna long.

float f = 5.8f;
int roundedF = Math.round(f); // 6

double d = 5.8;
long roundedD = Math.round(d); // 6

Atenção: às vezes isso surpreende — você arredonda um double e recebe um long! Se você precisa de um int, terá de fazer um casting explícito:

int rounded = (int) Math.round(5.6); // 6

3. Arredondando para a quantidade desejada de casas decimais

Frequentemente é preciso arredondar não para o inteiro, mas, por exemplo, para duas casas decimais (para valores monetários, percentuais etc.).

Em Java não há um método “mágico” como Math.roundTo2Digits(), mas dá para fazer isso manualmente.

Método 1: truque matemático com multiplicação e divisão

1. Multiplique o número por 100 (se quiser duas casas).
2. Arredonde para inteiro com Math.round.
3. Divida de volta por 100.

Exemplo:

double value = 3.14159;
double rounded = Math.round(value * 100.0) / 100.0;
System.out.println(rounded); // 3.14

Como isso funciona:

• 3.14159 * 100 = 314.159
• Math.round(314.159) = 314
• 314 / 100.0 = 3.14

4. Formatação de números: classe DecimalFormat

Às vezes, não basta arredondar um número — é preciso exibi-lo bem, com uma quantidade específica de casas decimais, zeros à esquerda, separadores de milhar e afins. Para isso, em Java há a classe DecimalFormat do pacote java.text.

Como o DecimalFormat funciona

1. Crie um objeto com o padrão desejado.
2. Chame o 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

Como o padrão funciona

• "0.00" — sempre duas casas decimais (mesmo se o número for inteiro).
• "0.###" — até três casas decimais; zeros supérfluos não são exibidos.
• "#,##0.00" — adiciona separadores de milhar (por exemplo, "1,234.56").

Exemplos de padrões diferentes:

"0.00"

"0.00"

"0.00"

"0.###"

"0.###"

"#,##0.00"

Exemplo com separadores de milhar

DecimalFormat df = new DecimalFormat("#,##0.00");
System.out.println(df.format(1234567.89)); // 1,234,567.89

Exemplo: saída sem zeros desnecessários

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. Formatação com String.format

Às vezes, para casos simples, é conveniente usar String.format — uma forma integrada de formatar strings, parecida com o printf em outras linguagens.

double value = 3.14159;
System.out.println(String.format("%.2f", value)); // 3.14

Aqui, "%.2f" — significa “exibir o número com duas casas decimais”.

Comparação das abordagens:

• DecimalFormat — mais poderoso, suporta padrões e localização, e é prático para separadores de milhar.
• String.format — mais simples quando você só precisa definir a quantidade de casas decimais.

6. Particularidades de arredondamento: Math.floor, Math.ceil, Math.rint

• Math.floor(x) — arredonda para baixo (para o menor valor), inclusive para números negativos.
• Math.ceil(x) — arredonda para cima (para o maior valor).
• Math.rint(x) — arredonda para o inteiro mais próximo, mas retorna double.

Exemplos:

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 (sim, não é erro de digitação!)
System.out.println(Math.rint(3.5));  // 4.0

Atenção: Math.rint às vezes arredonda “para o inteiro par mais próximo” — essa regra (também chamada de arredondamento bancário, banker's rounding) ajuda a reduzir o acúmulo de erros em cálculos em massa.

7. Detalhes úteis

Visualização: tabela de arredondamentos

Arredondar não é o mesmo que formatar!

É muito importante entender a diferença entre arredondamento e formatação.

• Arredondamento — alteração do valor numérico (por exemplo, 2.718 → 2.72).
• Formatação — alteração apenas da aparência na saída (por exemplo, 2.718 → "2.72" na tela, mas na memória permanece 2.718).

double x = 2.718;
System.out.println(String.format("%.2f", x)); // 2.72
System.out.println(x); // 2.718

Se você pretende usar o número arredondado em cálculos posteriores — arredonde matematicamente! Se for apenas para exibir — formate.

8. Erros comuns ao arredondar e formatar números

Erro nº 1: Arredondar apenas para exibição e depois continuar usando o número “comprido”.
Situação muito comum — exibir um valor bem formatado na tela e depois usar o número “longo” original nos cálculos. Para dinheiro, notas e totais — primeiro arredonde (por exemplo, Math.round ou a técnica de multiplicação/divisão), depois salve/entregue ao usuário.

Erro nº 2: Esperar que Math.round(x) retorne double com duas casas decimais.
Math.round() sempre arredonda para o inteiro mais próximo: para float retorna int, para double — long. Para duas casas, use multiplicação/divisão ou formatação.

Erro nº 3: Usar DecimalFormat para cálculos.
DecimalFormat.format() retorna uma string. Usá-la em aritmética não funciona: você terá um erro de compilação ou NumberFormatException ao converter de volta.

Erro nº 4: Padrão DecimalFormat incorreto.
O padrão deve corresponder ao esperado: "0.00" sempre mostrará duas casas ("2.00"), e "0.##" removerá zeros supérfluos ("2", "2.1", "2.12").

Erro nº 5: Perda de precisão ao dividir por 100.
Se você divide int por int, o resultado também é int!

int a = 5;
System.out.println(a / 2); // 2, e não 2.5!

Para que a divisão seja “fracionária”, pelo menos um dos operandos deve ser double:

int a = 5;
System.out.println(a / 2.0); // 2.5