Problema con flotante y doble:

• Diseñado para cálculos científicos y matemáticos, realiza aritmética binaria de punto flotante.
• No apto para cálculos monetarios o situaciones que requieran respuestas exactas.
• No se pueden representar con precisión potencias negativas de diez, como 0,1, lo que genera errores.

Ejemplo 1:
Cálculo incorrecto al restar montos en dólares:

System.out.println(1.03 - 0.42);  // Resultado: 0.6100000000000001

Ejemplo 2:
Error al comprar nueve artículos a 10 centavos cada uno:

System.out.println(1.00 - 9 * 0.10);  // Resultado: 0.09999999999999998

Incluso redondeando, los errores persisten.
Problema con los cálculos progresivos, como cuando se compran dulces a precios incrementales de 0,10 a 1,00.

Ejemplo 3:
Error al comprar dulces hasta no tener más dinero:

double funds = 1.00;
for (double price = 0.10; funds >= price; price  = 0.10) {
    funds -= price;
}
System.out.println(funds);  // Resultado: 0.3999999999999999

Solución 1: usar BigDecimal

• Ideal para cálculos financieros y situaciones donde la precisión es esencial.
• Evite utilizar el constructor doble de BigDecimal, prefiriendo el constructor String.

Ejemplo con 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

El cálculo ahora es preciso.

Desventajas de BigDecimal:

• Menos cómodo de usar que los tipos primitivos.
• Más lento, especialmente para grandes volúmenes de operaciones.

Solución 2: usar int o long

• Para evitar problemas de precisión, calcula en centavos, usando int o long en lugar de dólares con double.

Ejemplo con int (en 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

El cálculo es rápido y preciso.

Conclusión:

• No utilice flotante ni doble para cálculos que requieran precisión exacta.
• Utilice BigDecimal para cálculos monetarios o situaciones que requieran precisión decimal.
• Utilice int o long para cálculos financieros que no involucren números grandes, haciendo los cálculos en centavos.

Opciones:

• Para hasta 9 dígitos, utilice int.
• Para hasta 18 dígitos, utilice largo.
• Para cantidades mayores, utilice BigDecimal.
• Este resumen muestra que, dependiendo del contexto, elegir entre BigDecimal, int o long puede optimizar tanto la precisión como el rendimiento.