This content originally appeared on DEV Community and was authored by Java Efetivo (livro)
Problema com float e double:
- Projetados para cálculos científicos e matemáticos, executam aritmética binária de ponto flutuante.
- Não são adequados para cálculos monetários ou situações que exigem respostas exatas.
- Não conseguem representar com precisão potências negativas de dez, como 0.1, o que leva a erros.
Exemplo 1:
Cálculo incorreto ao subtrair valores em dólares:
System.out.println(1.03 - 0.42); // Resultado: 0.6100000000000001
Exemplo 2:
Erro ao comprar nove itens de 10 centavos cada:
System.out.println(1.00 - 9 * 0.10); // Resultado: 0.09999999999999998
Mesmo arredondando, os erros persistem.
Problema com cálculos progressivos, como ao comprar doces a preços incrementais de 0.10 a 1.00.
Exemplo 3:
Erro ao comprar doces até não ter mais dinheiro:
double funds = 1.00;
for (double price = 0.10; funds >= price; price += 0.10) {
funds -= price;
}
System.out.println(funds); // Resultado: 0.3999999999999999
Solução 1: Usar BigDecimal
- Ideal para cálculos financeiros e situações em que precisão é fundamental.
- Evitar o uso do construtor double de BigDecimal, preferindo o construtor String.
Exemplo com BigDecimal:
BigDecimal funds = new BigDecimal("1.00");
BigDecimal price = new BigDecimal("0.10");
int itemsBought = 0;
while (funds.compareTo(price) >= 0) {
funds = funds.subtract(price);
price = price.add(new BigDecimal("0.10"));
itemsBought++;
}
System.out.println(itemsBought + " items bought. Money left: " + funds);
// Resultado: 4 items bought. Money left: 0.00
O cálculo agora é preciso.
Desvantagens de BigDecimal:
- Menos conveniente de usar do que os tipos primitivos.
- Mais lento, especialmente para grandes volumes de operações.
Solução 2: Usar int ou long
- Para evitar os problemas de precisão, faça cálculos em centavos, usando int ou long em vez de dólares com double.
Exemplo com int (em centavos):
int funds = 100; // 1.00 dólar = 100 centavos
int price = 10; // 0.10 dólar = 10 centavos
int itemsBought = 0;
while (funds >= price) {
funds -= price;
price += 10;
itemsBought++;
}
System.out.println(itemsBought + " items bought. Money left: " + funds);
// Resultado: 4 items bought. Money left: 0
O cálculo é rápido e preciso.
Conclusão:
- Não use float ou double para cálculos que exigem precisão exata.
- Use BigDecimal para cálculos monetários ou situações que exigem precisão decimal.
- Use int ou long para cálculos financeiros que não envolvam grandes números, fazendo os cálculos em centavos.
Escolhas:
- Para até 9 dígitos, use int.
- Para até 18 dígitos, use long.
- Para quantidades maiores, use BigDecimal.
- Este resumo mostra que, dependendo do contexto, a escolha entre BigDecimal, int ou long pode otimizar tanto a precisão quanto o desempenho.
This content originally appeared on DEV Community and was authored by Java Efetivo (livro)
Java Efetivo (livro) | Sciencx (2024-10-09T22:21:22+00:00) Item 60: Evite o float e o double caso sejam necessárias respostas exatas. Retrieved from https://www.scien.cx/2024/10/09/item-60-evite-o-float-e-o-double-caso-sejam-necessarias-respostas-exatas/
Please log in to upload a file.
There are no updates yet.
Click the Upload button above to add an update.