Como verificar se a variável BigDecimal == 0 em java?

Eu tenho o seguinte código em Java;

BigDecimal price; // assigned elsewhere

if (price.compareTo(new BigDecimal("0.00")) == 0) {
    return true;
}

Qual é a melhor maneira de escrever a condição if?

Use em compareTo(BigDecimal.ZERO)vez de equals():

if (price.compareTo(BigDecimal.ZERO) == 0) // see below

Comparando com a BigDecimalconstante BigDecimal.ZEROevita ter que construir new BigDecimal(0)cada execução.

Para sua informação, BigDecimaltambém tem constantes BigDecimal.ONEe BigDecimal.TENpara sua conveniência.

Nota!

A razão pela qual você não pode usar BigDecimal#equals()é que ela leva em consideração a escala :

new BigDecimal("0").equals(BigDecimal.ZERO) // true
new BigDecimal("0.00").equals(BigDecimal.ZERO) // false!

portanto, não é adequado para uma comparação puramente numérica. No entanto, BigDecimal.compareTo()não considera escala ao comparar:

new BigDecimal("0").compareTo(BigDecimal.ZERO) == 0 // true
new BigDecimal("0.00").compareTo(BigDecimal.ZERO) == 0 // true

Como alternativa, signum () pode ser usado:

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

Há uma constante que você pode verificar:

someBigDecimal.compareTo(BigDecimal.ZERO) == 0

Eu costumo usar o seguinte:

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

Como alternativa, acho que vale a pena mencionar que o comportamento dos métodos igual e compareTo na classe BigDecimal não são consistentes entre si .

Isso basicamente significa que:

BigDecimal someValue = new BigDecimal("0.00");
System.out.println(someValue.compareTo(BigDecimal.ZERO)==0); //true
System.out.println(someValue.equals(BigDecimal.ZERO)); //false

Portanto, você deve ter muito cuidado com a escala em sua someValuevariável, caso contrário, obterá um resultado inesperado.

Você deseja usar equals (), pois eles são objetos, e utilizar a instância ZERO integrada:

if(selectPrice.equals(BigDecimal.ZERO))

Observe que .equals()leva em consideração a escala, portanto, a menos que selectPrice seja a mesma escala (0) .ZERO, isso retornará false.

Para tirar a escala da equação, por assim dizer:

if(selectPrice.compareTo(BigDecimal.ZERO) == 0)

Devo observar que, para certas situações matemáticas 0.00 != 0, é por isso que imagino .equals()leva em conta a escala. 0.00dá precisão ao centésimo lugar, enquanto 0que não é tão preciso. Dependendo da situação que você pode querer manter .equals().

GriffeyDog está definitivamente correto:

Código:

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)));

Resultados:

myBigDecimal=0.000000
BigDecimal.valueOf(0.000000)=0.0
 equals=false
compare=true

Embora eu compreenda as vantagens da comparação BigDecimal, não consideraria uma construção intuitiva (como os operadores ==, <,>, <=,> = são). Quando você está segurando um milhão de coisas (ok, sete coisas) em sua cabeça, qualquer coisa que possa reduzir sua carga cognitiva é uma coisa boa. Então, eu criei algumas funções úteis de conveniência:

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);
}

Aqui está como usá-los:

    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));

Os resultados são assim:

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

Só quero compartilhar aqui algumas extensões úteis para o kotlin

fun BigDecimal.isZero() = compareTo(BigDecimal.ZERO) == 0
fun BigDecimal.isOne() = compareTo(BigDecimal.ONE) == 0
fun BigDecimal.isTen() = compareTo(BigDecimal.TEN) == 0

BigDecimal.ZERO.setScale(2).equals(new BigDecimal("0.00"));

Há uma constante estática que representa 0 :

BigDecimal.ZERO.equals(selectPrice)

Você deve fazer isso em vez de:

selectPrice.equals(BigDecimal.ZERO)

para evitar o caso onde selectPriceestá null.