Élément Évitez de flotter et de doubler si des réponses exactes sont requises

Problème avec float et double :

• Conçu pour les calculs scientifiques et mathématiques, effectuez de l'arithmétique binaire à virgule flottante.
• Ne convient pas aux calculs monétaires ou aux situations qui nécessitent des réponses exactes.
• Ils ne peuvent pas représenter avec précision les puissances négatives de dix, telles que 0,1, ce qui conduit à 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 en achetant des 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 constructeur double 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, surtout pour les gros volumes d'opérations.

Solution 2 : Utiliser int ou long

• Pour éviter les problèmes de précision, effectuez les calculs 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 centimes.

Choix :

• Pour un maximum de 9 chiffres, utilisez int.
• Pour un maximum de 18 chiffres, utilisez long.
• Pour de plus grandes quantités, 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.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!