Ao realizar cálculos financeiros ou que exigem alta precisão, o tipo primitivo double em Java pode apresentar problemas de arredondamento. O BigDecimal é a classe recomendada para lidar com essas situações.

Exemplo de Operações:

import java.math.BigDecimal;

public class CalculosPrecisos {

   public static void main(String[] args) {
       double valor1 = 1.234;
       double valor2 = 2.341;

       // Problemas com double
       System.out.println("Soma com double: " + (valor1 + valor2)); // Saída: 3.575
       System.out.println("Multiplicação com double: " + (valor1 * valor2)); // Saída com imprecisão

       // Usando BigDecimal para operações precisas
       BigDecimal num1 = new BigDecimal(Double.toString(valor1));
       BigDecimal num2 = new BigDecimal(Double.toString(valor2));

       // Adição
       System.out.println("Soma com BigDecimal: " + num1.add(num2).doubleValue()); // Saída: 3.575

       // Subtração
       System.out.println("Subtração com BigDecimal: " + num1.subtract(num2).doubleValue()); // Saída: -1.107

       // Multiplicação
       System.out.println("Multiplicação com BigDecimal: " + num1.multiply(num2).doubleValue()); // Saída: 2.888794

       // Divisão com arredondamento
       // Divide num1 por num2, mantendo 2 casas decimais com arredondamento para cima (HALF_UP)
       System.out.println("Divisão com BigDecimal: " + num1.divide(num2, 2, BigDecimal.ROUND_HALF_UP)); // Saída: 0.53
   }
}
   

A conversão direta de tipos de ponto flutuante (como double) para BigDecimal pode herdar imprecisões. É crucial entender como o BigDecimal é instanciado para evitar problemas de precisão.

Instanciação e Conversão:

O construtor BigDecimal(double) pode levar a resultadso inesperados devido à forma como os doubles são representados internamente. A maneira recomendada de criar um BigDecimal a partir de um double é utilizando o método estático BigDecimal.valueOf(double), que converte o double para sua representação de string decimal antes de criar o objeto BigDecimal.

import java.math.BigDecimal;

public class PrecisaoBigDecimal {

   public static void main(String[] args) {
       // Exemplo de problema com construtor new BigDecimal(double)
       Object obj = 0.1;
       if (obj instanceof Number) {
           // Cria BigDecimal a partir do valor aproximado do double
           BigDecimal resultado1 = new BigDecimal(((Number) obj).doubleValue());
           System.out.println("Resultado com new BigDecimal(double): " + resultado1);

           // Cria BigDecimal a partir da representação decimal do double
           BigDecimal resultado2 = BigDecimal.valueOf(((Number) obj).doubleValue());
           System.out.println("Resultado com BigDecimal.valueOf(double): " + resultado2);
       }

       // Exemplo com soma e formatação
       BigDecimal b1 = new BigDecimal("1.23"); // Usando String é mais seguro
       BigDecimal b2 = new BigDecimal("1.24");
       BigDecimal b3 = new BigDecimal("1.25");

       BigDecimal soma = b1.add(b2).add(b3);
       System.out.println("Soma sem formatação: " + soma); // Pode apresentar imprecisão

       // Formatando a soma para 2 casas decimais com arredondamento (ROUND_HALF_UP)
       BigDecimal somaFormatada = soma.setScale(2, BigDecimal.ROUND_HALF_UP);
       System.out.println("Soma formatada: " + somaFormatada);
   }
}
   

Saída esperada para o primeiro bloco:

Resultado com new BigDecimal(double): 0.1000000000000000055511151231257827021181583404541015625
Resultado com BigDecimal.valueOf(double): 0.1
   

Conclusão: Utilize BigDecimal.valueOf(double) ou o construtor BigDecimal(String) para evitar imprecisões ao instanciar BigDecimal.

A imprecisão em tipos de ponto flutuante como double surge da tentativa de representar números decimais exatos (como 0.1) em um sistema binário. Muitos números decimais que são finitos em base 10 tornam-se dízimas periódicas infinitsa em base 2, o que leva a aproximações quando armazenados em um número fixo de bits.

• Representação Binária: Números como 0.1 (decimal) são representados como frações binárias de período infinito (ex: 0.0001100110011...). A limitação de 64 bits do double armazena apenas uma aproximação.
• Acúmulo de Erros: Operações aritméticas realizadas sobre essas aproximações podem acumular erros, resultando em valores que não são exatamente os esperados. Por exemplo, 0.1 + 0.2 pode não resultar em exatamente 0.3.
• Como BigDecimal Resolve: BigDecimal utiliza uma representação decimal interna (um inteiro de precisão arbitrária e um valor de escala), evitando a conversão para binário e, consequentemente, a imprecisão inerente.

Métodos de Instanciação de BigDecimal:

• BigDecimal.valueOf(double): Recomendado. Converte o double para String decimal antes de criar o BigDecimal.
• new BigDecimal(String): Recomendado. Cria um BigDecimal com a repreesntação exata do número na String.
• new BigDecimal(double): Não recomendado. Pode introduzir imprecisões do double.

Alternativa para Casos Específicos: Para cálculos com precisão fixa e alta performance, pode-se usar tipos inteiros (long ou int) para representar a menor unidade (ex: centavos de moeda), evitando completamente a aritmética de ponto flutuante. Contudo, para cálculos decimais gerais, BigDecimal é a solução padrão.

import java.math.BigDecimal;

public class ComparandoInstanciamentos {

   public static void main(String[] args) {
       double val1 = 0.1d;
       double val2 = 0.2d;
       double somaDouble = val1 + val2;
       System.out.println("Soma de doubles: " + somaDouble); // Exibe 0.30000000000000004

       // Soma usando new BigDecimal(double)
       BigDecimal somaPrecisa1 = new BigDecimal(val1).add(new BigDecimal(val2));
       System.out.println("Soma com new BigDecimal(double): " + somaPrecisa1); // Impreciso

       // Soma usando BigDecimal.valueOf(double)
       BigDecimal somaPrecisa2 = BigDecimal.valueOf(val1).add(BigDecimal.valueOf(val2));
       System.out.println("Soma com BigDecimal.valueOf(double): " + somaPrecisa2); // Exato: 0.3
   }
}
   

BigDecimal oferece flexibilidade no controle de como os números são arredondados durante operações que exigem a redução de precisão. Abaixo estão alguns dos modos mais comuns:

• ROUND_DOWN: Trunca o número, removendo os dígitos excedentes sem arredondamento. (Ex: 1.28 para 1 casa decimal -> 1.2)
• ROUND_UP: Arredonda para cima, afastando-se de zero. (Ex: 1.21 para 1 casa decimal -> 1.3)
• ROUND_HALF_UP: Arredondamento "comum" (quatro para cima, cinco para cima). (Ex: 2.35 para 1 casa decimal -> 2.4)
• ROUND_HALF_DOWN: Quatro para baixo, cinco para baixo. (Ex: 2.35 para 1 casa decimal -> 2.3)
• ROUND_CEILING: Arredonda em direção ao infinito positivo.
• ROUND_FLOOR: Arredonda em direção ao infinito negativo.
• ROUND_HALF_EVEN: Arredondamento para o vizinho mais próximo; em caso de empate (exatamente 5), arredonda para o dígito par mais próximo.
• ROUND_UNNECESSARY: Lança uma exceção se o número não puder ser representado exatamente na precisão especificada.

A divisão com BigDecimal requer atenção especial para evitar ArithmeticException, que ocorre quando o resultado da divisão não é representável exatamente (divisão não exata).

Exemplos de Uso do divide():

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

public class DivisaoBigDecimal {

   public static void main(String[] args) {
       BigDecimal dividendo = new BigDecimal("100.00");
       BigDecimal divisor = new BigDecimal("3.00");

       try {
           // Tentativa de divisão sem especificar escala ou modo de arredondamento
           BigDecimal quocienteErro = dividendo.divide(divisor);
           System.out.println("Divisão (erro): " + quocienteErro);
       } catch (ArithmeticException e) {
           System.out.println("Erro na divisão: " + e.getMessage()); // Lança ArithmeticException
       }

       // Divisão com modo de arredondamento (usa a escala do dividendo se não especificada)
       // Aqui, dividendo1 tem escala 1 (100.0), então o resultado terá precisão de 1 casa decimal.
       BigDecimal dividendo1 = new BigDecimal("100.0");
       BigDecimal divisor1 = new BigDecimal("3.00");
       BigDecimal quociente1 = dividendo1.divide(divisor1, RoundingMode.HALF_UP);
       System.out.println("Divisão com HALF_UP (escala implícita): " + quociente1); // Saída: 33.3

       // Divisão especificando escala e modo de arredondamento
       BigDecimal dividendo2 = new BigDecimal("100.0");
       BigDecimal divisor2 = new BigDecimal("3.00");
       // Divide e arredonda para 2 casas decimais usando ROUND_HALF_UP
       BigDecimal quociente2 = dividendo2.divide(divisor2, 2, RoundingMode.HALF_UP);
       System.out.println("Divisão com escala 2 e HALF_UP: " + quociente2); // Saída: 33.33

       // Utilizando setScale para ajustar a precisão após a divisão
       BigDecimal dividendo3 = new BigDecimal("100.0");
       BigDecimal divisor3 = new BigDecimal("3.00");
       // Divide com 4 casas decimais
       BigDecimal quociente3 = dividendo3.divide(divisor3, 4, RoundingMode.HALF_UP);
       System.out.println("Divisão com 4 casas decimais: " + quociente3); // Saída: 33.3333
       // Ajusta o resultado para 3 casas decimais
       BigDecimal resultadoAjustado = quociente3.setScale(3, RoundingMode.HALF_UP);
       System.out.println("Resultado ajustado para 3 casas: " + resultadoAjustado); // Saída: 33.333
   }
}
   

O método multiply() realiza a multiplicação entre dois objetos BigDecimal. A escala resultante é a soma das escalas dos operandos.

import java.math.BigDecimal;

public class MultiplicacaoBigDecimal {

   public static void main(String[] args) {
       BigDecimal fator1 = new BigDecimal("100.0"); // Escala 1
       BigDecimal fator2 = new BigDecimal("0.1");  // Escala 1
       BigDecimal fator3 = new BigDecimal("0.5");  // Escala 1

       // Multiplicação: (100.0 * 0.1)
       // Escala resultante = 1 + 1 = 2
       BigDecimal resultado1 = fator1.multiply(fator2);
       System.out.println("Resultado 1: " + resultado1); // Saída: 10.00 (Escala 2)

       // Multiplicação: (10.00 * 0.5)
       // Escala resultante = 2 + 1 = 3
       BigDecimal resultado2 = resultado1.multiply(fator3);
       System.out.println("Resultado 2: " + resultado2); // Saída: 5.000 (Escala 3)
   }
}