web-dev-qa-db-fra.com

Comment vérifier si la variable BigDecimal == en java?

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?

javabigdecimal
166
JoJo

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é.

Remarque!

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
365
Bohemian

Alternativement, signum () peut être utilisé:

if (price.signum() == 0) {
    return true;
}
80
kman

Il y a une constante que vous pouvez vérifier contre:

someBigDecimal.compareTo(BigDecimal.ZERO) == 0
23
pablochan

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.

5
Edwin Dalorzo

J'utilise habituellement ce qui suit:

if (selectPrice.compareTo(BigDecimal.ZERO) == 0) { ... }
5
gpol

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().

4
NominSim

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
0
Nokuap

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
0
Tihamer