Problème avec float et double :

• Conçu pour les calculs scientifiques et mathématiques, effectuez l'arithmétique binaire à virgule flottante.
• Ne convient pas aux calculs monétaires ou aux situations nécessitant des réponses exactes.
• Impossible de représenter avec précision les puissances négatives de dix, telles que 0,1, ce qui entraîne des erreurs.

Exemple 1 :
Calcul incorrect lors de la soustraction des montants en dollars :

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

Exemple 2 :
Erreur lors de l'achat de neuf articles à 10 centimes chacun :

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

Même en arrondissant, des erreurs persistent.
Problème avec les calculs progressifs, comme lors de l'achat de bonbons à des prix incrémentiels de 0,10 à 1,00.

Exemple 3 :
Erreur lors de l'achat de bonbons jusqu'à ce que vous n'ayez plus d'argent :

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 : utiliser BigDecimal

• Idéal pour les calculs financiers et les situations où la précision est essentielle.
• Évitez d'utiliser le double constructeur de BigDecimal, préférant le constructeur String.

Exemple avec 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

Le calcul est désormais précis.

Inconvénients de BigDecimal :

• Moins pratique à utiliser que les types primitifs.
• Plus lent, en particulier pour les gros volumes d'opérations.

Solution 2 : utiliser int ou long

• Pour éviter les problèmes de précision, calculez en cents, en utilisant int ou long au lieu de dollars avec double.

Exemple avec int (en centimes) :

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

Le calcul est rapide et précis.

Conclusion:

• N'utilisez pas float ou double pour les calculs qui nécessitent une précision exacte.
• Utilisez BigDecimal pour les calculs monétaires ou les situations nécessitant une précision décimale.
• Utilisez int ou long pour les calculs financiers qui n'impliquent pas de grands nombres, en effectuant les calculs en cents.

Choix :

• Pour un maximum de 9 chiffres, utilisez int.
• Pour un maximum de 18 chiffres, utilisez long.
• Pour des quantités plus importantes, utilisez BigDecimal.
• Ce résumé montre que, selon le contexte, choisir entre BigDecimal, int ou long peut optimiser à la fois la précision et les performances.