Arredondando números em Java

Números de ponto flutuante (float, double) são usados ​​ao calcular expressões que requerem precisão decimal. Freqüentemente, é necessária alta precisão em operações contábeis e outras operações de computação. Mas será que sempre precisamos de uma longa “cauda” de números após a vírgula? Talvez uma precisão de três partes reais seja suficiente para nós? E estamos satisfeitos com esta opção, como realizar o arredondamento corretamente? É exatamente sobre isso que falaremos hoje: veremos maneiras de arredondar números em Java .

Formato de string

Como primeiro método, veremos o arredondamento duplo:

double value = 34.766674;
String result = String.format("%.3f",value);
System.out.print(result);//  34,767

Como resultado, formataremos nosso número de ponto flutuante 34766674 com precisão de 3 casas decimais , pois nas instruções de formatação especificamos três casas decimais "%.3f. Por sua vez, %f ao formatar uma string indica o tipo de ponto flutuante numbers, que inclui o tipo de dados double e float em Java. No exemplo acima, enviamos o valor resultante para o console. Agora a questão é: como poderíamos encurtar isso? É simples: você precisa usar printf, que por sua vez é formato + impressão. Como resultado, o nosso exemplo anterior seria reduzido a:

double value = 34.766674;
System.out.printf("%.3f",value);

Além deste método , a instância out da classe PrintStream também possui um método format, que funciona de forma semelhante:

double value = 34.766674;
System.out.format("%.3f",value);

O arredondamento ocorre no modo HALF_UP - em direção ao número mais próximo daquele que está sendo cortado (para 0 ou 10). Se esses números forem equidistantes (no caso de 5), o arredondamento será realizado. Exemplo:

String firstResult = String.format("%.3f",7.0004);// 7,000
String secondResult = String.format("%.3f",7.0005);// 7,001
String thirdResult = String.format("%.3f",7.0006);// 7,001

Discutiremos os modos de arredondamento com mais detalhes abaixo.

Formato Decimal

Outra opção é usar a classe DecimalFormat . Ele foi projetado para formatar qualquer número em Java, seja um número inteiro ou de ponto flutuante. Quando instanciamos DecimalFormat, podemos passar a ele uma string de formato. Indicará quantas casas decimais serão formatadas para a entrada. Este é o aspecto do nosso exemplo usando DecimalFormat :

double value = 34.766674;
DecimalFormat decimalFormat = new DecimalFormat( "#.###" );
String result = decimalFormat.format(value);
System.out.print(result);//34,767

A linha #.### é um padrão que indica que estamos formatando o valor passado com 3 casas decimais. Para alterar o padrão após a criação do objeto DecimalFormat, você pode usar seus métodos applyPattern e applyLocalizedPattern :

DecimalFormat decimalFormat = new DecimalFormat("#.###");
decimalFormat.applyPattern("#.#");
decimalFormat.applyLocalizedPattern("#.#####");

Mas hoje estamos falando de arredondamento, não é? Ao truncar um número com casas decimais além do padrão especificado, DecimalFormat arredonda o número para cima se o último número truncado for maior que 5. Mas e se o número for 5? Acontece que está exatamente no meio entre os números inteiros mais próximos. E então? Neste caso, o número anterior é levado em consideração. Se for par, o arredondamento é feito:

DecimalFormat decimalFormat = new DecimalFormat("#.###");
String result = decimalFormat.format(7.4565);
System.out.println((result));// 7,457

Se for ímpar, não é executado:

DecimalFormat decimalFormat = new DecimalFormat("#.###");
String result = decimalFormat.format(7.4575);
System.out.println((result));// 7,457

Há uma pequena diferença entre a formatação de números de ponto flutuante usando String.format() e DecimalFormat.format(). O primeiro sempre imprimirá zeros à direita, mesmo que não haja parte fracionária. Por exemplo:

String firstResult = String.format("%.3f", 7.000132);
System.out.println((firstResult)); // 7.000

DecimalFormat decimalFormat = new DecimalFormat("#.###");
String secondResult = decimalFormat.format(7.000132);
System.out.println((secondResult));  // 7

Como podemos ver, ao formatar o número 7.000132 com três casas decimais, o método format() de String produzirá 7.000, enquanto o método format() de DecimalFormat produzirá 7. Ou seja, você pode escolher String.format() ou DecimalFormat.format( ) dependendo se você precisa de zeros à direita ou não. Usando os métodos descritos acima, obtivemos o resultado na forma de uma string. Vejamos maneiras de retornar exatamente os valores numéricos.

Matemática

É impossível não mencionar uma classe especial adaptada para diversas operações aritméticas com números - Math . Esta classe também possui métodos para arredondamento, mas diferentemente dos já descritos, eles não permitem definir um determinado número de casas decimais, mas sim arredondar para um número inteiro:

• Math.ceil() arredonda para o número inteiro mais próximo, mas não retorna um tipo inteiro, mas um duplo:

  double value = 34.777774;
  double result = Math.ceil(value);
  System.out.println((result)); //35.0

  Mesmo se tivermos 34.0000000, depois de usar Math.ceil ainda obteremos 35,0.

  Math.floor() arredonda para o número inteiro mais próximo, retornando também o resultado como double:

  double value = 34.777774;
  double result = Math.floor(value);
  System.out.println((result)); //34.0

  Novamente, mesmo que tenhamos um valor de 34,999999999, depois de usar Math.floor obteremos 34,0.

• Math.round() - arredonda para o número inteiro mais próximo, dando o resultado int:

  double value = 34.777774;
  int result = Math.round(value);
  System.out.println((result)); //35

  Se nosso número for 34,5, ele será arredondado para 35, mas se for um pouco menor que 34,499, o número será truncado para 34.

  Para não simplesmente cortar toda a parte real, mas regular esse processo para um certo número de casas decimais e ao mesmo tempo arredondar, o número é multiplicado por 10^n (10 elevado à potência de n), onde n é igual ao número de casas decimais necessárias. Depois disso, algum método da classe Math é usado para arredondar e depois dividir novamente por 10^n:

  double value = 34.777774;
  double scale = Math.pow(10, 3);
  double result = Math.ceil(value * scale) / scale;
  System.out.println((result)); //34.778

  Math.pow - aceita dois argumentos. O primeiro é o número, o segundo é a potência à qual ele precisa ser elevado.

Arredondamento com BigDecimal

BigDecimal é uma classe que permite trabalhar com números de ponto flutuante. Em particular, sua principal característica é poder armazenar números fracionários de comprimento arbitrário (ou seja, não há limite no intervalo do número). Além disso, esta classe armazena vários métodos de processamento aritmético, incluindo arredondamento. A classe deste objeto pode ser criada definindo o construtor como double, string para exibir um número de ponto flutuante, double e MathContext e assim por diante. MathContext é uma combinação de RoundingMode e um número que descreve o número total de dígitos no valor pesquisado. Regras de arredondamento RoundingMode: DOWN - arredondamento para zero. UP — arredondamento do modo zero. TETO - arredondamento para infinito positivo. FLOOR - arredondamento para infinito negativo. HALF_UP - Arredonda para o “vizinho mais próximo” se ambos os vizinhos não forem equidistantes (ou seja, quando o número a ser arredondado for 5). Neste caso, é realizado o arredondamento. HALF_DOWN - arredondando para o “vizinho mais próximo”. Se ambos os vizinhos não forem equidistantes, neste caso arredonde para baixo. HALF_EVEN - Arredonda para o "vizinho mais próximo" se ambos os vizinhos não forem equidistantes. Neste caso, arredonde para o vizinho par (como em DecimalFormat descrito acima). DESNECESSÁRIO - Utilizado para confirmar se a operação solicitada obteve o resultado correto. Portanto, o arredondamento não é necessário. Exemplo:

MathContext context = new MathContext(5, RoundingMode.HALF_UP);
double value = 34.777554;
BigDecimal result = new BigDecimal(value, context);
System.out.println(result); //34.778

Além da capacidade de definir uma regra de arredondamento no construtor, BigDecimal permite definir o modo de arredondamento após a criação da instância. Para fazer isso, use o método setScale , no qual você precisa definir o número de casas decimais e regras de arredondamento:

double value = 34.777554;
BigDecimal result = new BigDecimal(value);
result = result.setScale(3, RoundingMode.DOWN);
System.out.println(result); //34.777

BigDecimal também possui variáveis ​​int internas projetadas para definir o modo de arredondamento ( ROUND_DOWN , ROUND_CEILING , ROUND_FLOOR ...) Estas são regras de arredondamento semelhantes às apresentadas na classe RoundingMode e são usadas de forma semelhante em setScale :

BigDecimal result = new BigDecimal(value);
result = result.setScale(3, BigDecimal.ROUND_DOWN);

Leia mais sobre a classe BigDecimal neste artigo .