Problem with float and double:

• Designed for scientific and mathematical calculations, perform binary floating-point arithmetic.
• Not suitable for monetary calculations or situations that require exact answers.
• Cannot accurately represent negative powers of ten, such as 0.1, which leads to errors.

Example 1:
Incorrect calculation when subtracting dollar amounts:

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

Example 2:
Error when purchasing nine items for 10 cents each:

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

Even rounding, errors persist.
Problem with progressive calculations, such as when purchasing sweets at incremental prices of 0.10 to 1.00.

Example 3:
Error when buying sweets until you have no more money:

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

Solution 1: Use BigDecimal

• Ideal for financial calculations and situations where precision is essential.
• Avoid using BigDecimal's double constructor, preferring the String constructor.

Example with 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

The calculation is now precise.

Disadvantages of BigDecimal:

• Less convenient to use than primitive types.
• Slower, especially for large volumes of operations.

Solution 2: Use int or long

• To avoid precision problems, calculate in cents, using int or long instead of dollars with double.

Example with int (in cents):

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

The calculation is fast and accurate.

Conclusion:

• Do not use float or double for calculations that require exact precision.
• Use BigDecimal for monetary calculations or situations that require decimal precision.
• Use int or long for financial calculations that do not involve large numbers, doing the calculations in cents.

Choices:

• For up to 9 digits, use int.
• For up to 18 digits, use long.
• For larger quantities, use BigDecimal.
• This summary shows that, depending on the context, choosing between BigDecimal, int or long can optimize both precision and performance.