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

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

Barbara Streisand
Barbara Streisandoriginal
2024-10-10 08:08:29900parcourir

Item  Evite o float e o double caso sejam necessárias respostas exatas

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!

Déclaration:
Le contenu de cet article est volontairement contribué par les internautes et les droits d'auteur appartiennent à l'auteur original. Ce site n'assume aucune responsabilité légale correspondante. Si vous trouvez un contenu suspecté de plagiat ou de contrefaçon, veuillez contacter admin@php.cn