J'ai le code suivant en Java;
BigDecimal price; // assigned elsewhere
if (price.compareTo(new BigDecimal("0.00")) == 0) {
return true;
}
Quelle est la meilleure façon d'écrire la condition si?
Utilisez compareTo(BigDecimal.ZERO)
au lieu de equals()
:
if (price.compareTo(BigDecimal.ZERO) == 0) // see below
La comparaison avec le BigDecimal
constant BigDecimal.ZERO
évite de devoir créer une new BigDecimal(0)
à chaque exécution.
Pour votre information, BigDecimal
a aussi les constantes BigDecimal.ONE
et BigDecimal.TEN
pour votre commodité.
La raison pour laquelle vous ne pouvez pas utiliser BigDecimal#equals()
est que cela prend en compte scale:
new BigDecimal("0").equals(BigDecimal.ZERO) // true
new BigDecimal("0.00").equals(BigDecimal.ZERO) // false!
il ne convient donc pas à une comparaison purement numérique. Cependant, BigDecimal.compareTo()
ne considère pas l’échelle lorsqu’on compare:
new BigDecimal("0").compareTo(BigDecimal.ZERO) == 0 // true
new BigDecimal("0.00").compareTo(BigDecimal.ZERO) == 0 // true
Alternativement, signum () peut être utilisé:
if (price.signum() == 0) {
return true;
}
Il y a une constante que vous pouvez vérifier contre:
someBigDecimal.compareTo(BigDecimal.ZERO) == 0
Alternativement, je pense qu'il est utile de mentionner que le comportement des égaux et les méthodes compareTo dans la classe BigDecimal ne sont pas cohérents entre eux .
Cela signifie fondamentalement que:
BigDecimal someValue = new BigDecimal("0.00");
System.out.println(someValue.compareTo(BigDecimal.ZERO)==0); //true
System.out.println(someValue.equals(BigDecimal.ZERO)); //false
Par conséquent, vous devez faire très attention à l'échelle dans votre variable someValue
, sinon vous obtiendriez un résultat inattendu.
J'utilise habituellement ce qui suit:
if (selectPrice.compareTo(BigDecimal.ZERO) == 0) { ... }
Vous voudriez utiliser equals () car ce sont des objets et utiliser l'instance intégrée de ZERO:
if(selectPrice.equals(BigDecimal.ZERO))
Notez que .equals()
prend en compte l’échelle. Ainsi, à moins que selectPrice ait la même échelle (0) que .ZERO
, cela retournera false.
Pour sortir de l'équation pour ainsi dire:
if(selectPrice.compareTo(BigDecimal.ZERO) == 0)
Je devrais noter que pour certaines situations mathématiques, 0.00 != 0
, c’est pourquoi j’imagine que .equals()
prend l’échelle en compte. 0.00
donne une précision au centième, alors que 0
n'est pas très précis. En fonction de la situation, vous voudrez peut-être rester avec .equals()
.
Je veux juste partager ici quelques extensions utiles pour kotlin
fun BigDecimal.isZero() = compareTo(BigDecimal.ZERO) == 0
fun BigDecimal.isOne() = compareTo(BigDecimal.ONE) == 0
fun BigDecimal.isTen() = compareTo(BigDecimal.TEN) == 0
GriffeyDog est définitivement correct:
Code:
BigDecimal myBigDecimal = new BigDecimal("00000000.000000");
System.out.println("bestPriceBigDecimal=" + myBigDecimal);
System.out.println("BigDecimal.valueOf(0.000000)=" + BigDecimal.valueOf(0.000000));
System.out.println(" equals=" + myBigDecimal.equals(BigDecimal.ZERO));
System.out.println("compare=" + (0 == myBigDecimal.compareTo(BigDecimal.ZERO)));
Résultats:
myBigDecimal=0.000000
BigDecimal.valueOf(0.000000)=0.0
equals=false
compare=true
Bien que je comprenne les avantages de la comparaison BigDecimal, je ne le considérerais pas comme une construction intuitive (comme le sont les opérateurs ==, <,>, <=,> =). Lorsque vous avez dans votre tête un million de choses (ok, sept choses), tout ce que vous pouvez réduire votre charge cognitive est une bonne chose. J'ai donc construit quelques fonctions pratiques utiles:
public static boolean equalsZero(BigDecimal x) {
return (0 == x.compareTo(BigDecimal.ZERO));
}
public static boolean equals(BigDecimal x, BigDecimal y) {
return (0 == x.compareTo(y));
}
public static boolean lessThan(BigDecimal x, BigDecimal y) {
return (-1 == x.compareTo(y));
}
public static boolean lessThanOrEquals(BigDecimal x, BigDecimal y) {
return (x.compareTo(y) <= 0);
}
public static boolean greaterThan(BigDecimal x, BigDecimal y) {
return (1 == x.compareTo(y));
}
public static boolean greaterThanOrEquals(BigDecimal x, BigDecimal y) {
return (x.compareTo(y) >= 0);
}
Voici comment les utiliser:
System.out.println("Starting main Utils");
BigDecimal bigDecimal0 = new BigDecimal(00000.00);
BigDecimal bigDecimal2 = new BigDecimal(2);
BigDecimal bigDecimal4 = new BigDecimal(4);
BigDecimal bigDecimal20 = new BigDecimal(2.000);
System.out.println("Positive cases:");
System.out.println("bigDecimal0=" + bigDecimal0 + " == zero is " + Utils.equalsZero(bigDecimal0));
System.out.println("bigDecimal2=" + bigDecimal2 + " < bigDecimal4=" + bigDecimal4 + " is " + Utils.lessThan(bigDecimal2, bigDecimal4));
System.out.println("bigDecimal2=" + bigDecimal2 + " == bigDecimal20=" + bigDecimal20 + " is " + Utils.equals(bigDecimal2, bigDecimal20));
System.out.println("bigDecimal2=" + bigDecimal2 + " <= bigDecimal20=" + bigDecimal20 + " is " + Utils.equals(bigDecimal2, bigDecimal20));
System.out.println("bigDecimal2=" + bigDecimal2 + " <= bigDecimal4=" + bigDecimal4 + " is " + Utils.lessThanOrEquals(bigDecimal2, bigDecimal4));
System.out.println("bigDecimal4=" + bigDecimal4 + " > bigDecimal2=" + bigDecimal2 + " is " + Utils.greaterThan(bigDecimal4, bigDecimal2));
System.out.println("bigDecimal4=" + bigDecimal4 + " >= bigDecimal2=" + bigDecimal2 + " is " + Utils.greaterThanOrEquals(bigDecimal4, bigDecimal2));
System.out.println("bigDecimal2=" + bigDecimal2 + " >= bigDecimal20=" + bigDecimal20 + " is " + Utils.greaterThanOrEquals(bigDecimal2, bigDecimal20));
System.out.println("Negative cases:");
System.out.println("bigDecimal2=" + bigDecimal2 + " == zero is " + Utils.equalsZero(bigDecimal2));
System.out.println("bigDecimal2=" + bigDecimal2 + " == bigDecimal4=" + bigDecimal4 + " is " + Utils.equals(bigDecimal2, bigDecimal4));
System.out.println("bigDecimal4=" + bigDecimal4 + " < bigDecimal2=" + bigDecimal2 + " is " + Utils.lessThan(bigDecimal4, bigDecimal2));
System.out.println("bigDecimal4=" + bigDecimal4 + " <= bigDecimal2=" + bigDecimal2 + " is " + Utils.lessThanOrEquals(bigDecimal4, bigDecimal2));
System.out.println("bigDecimal2=" + bigDecimal2 + " > bigDecimal4=" + bigDecimal4 + " is " + Utils.greaterThan(bigDecimal2, bigDecimal4));
System.out.println("bigDecimal2=" + bigDecimal2 + " >= bigDecimal4=" + bigDecimal4 + " is " + Utils.greaterThanOrEquals(bigDecimal2, bigDecimal4));
Les résultats ressemblent à ceci:
Positive cases:
bigDecimal0=0 == zero is true
bigDecimal2=2 < bigDecimal4=4 is true
bigDecimal2=2 == bigDecimal20=2 is true
bigDecimal2=2 <= bigDecimal20=2 is true
bigDecimal2=2 <= bigDecimal4=4 is true
bigDecimal4=4 > bigDecimal2=2 is true
bigDecimal4=4 >= bigDecimal2=2 is true
bigDecimal2=2 >= bigDecimal20=2 is true
Negative cases:
bigDecimal2=2 == zero is false
bigDecimal2=2 == bigDecimal4=4 is false
bigDecimal4=4 < bigDecimal2=2 is false
bigDecimal4=4 <= bigDecimal2=2 is false
bigDecimal2=2 > bigDecimal4=4 is false
bigDecimal2=2 >= bigDecimal4=4 is false