If you have a few years of experience in the Java ecosystem and you’d like to share that with the community, have a look at our **Contribution Guidelines**.

# Check if BigDecimal Value Is Zero

Last modified: June 27, 2022

## 1. Overview

When we want to do decimal number calculations in Java, we may consider using the *BigDecimal* class.

In this short tutorial, we'll explore how to check if a *BigDecimal* object's value is zero.

## 2. Introduction to the Problem

The problem is actually pretty straightforward. Let's say we have a not-null *BigDecimal* object. We want to know whether its value is equal to zero.

Sharp eyes may have already realized that the requirement “*whether* *its value is equal to zero*” has implied the solution: using the *equals()* method. Further, the *BigDecimal* class provides a convenient *ZERO* constant object to indicate the zero value.

Indeed, this problem sounds pretty simple. We could simply check *BigDecimal.ZERO.equals(givenBdNumber)* to decide if the *givenBdNumber* object has the value zero. However, **if we don't know BigDeicmal‘s comparison intricacies, we may fall into a common pitfall**.

Next, let's take a closer look at it and address the proper ways to solve it.

## 3. The Common Pitfall of *BigDecimal* Comparison: Using the *equals* Method

First, let's create a *BigDecimal* object with zero as the value:

`BigDecimal BD1 = new BigDecimal("0");`

Now, let's check if *BD1*‘s value is zero using the *equals* method. For simplicity, let's do this in a unit test method:

`assertThat(BigDecimal.ZERO.equals(BD1)).isTrue();`

If we run the test, it'll pass. So far, so good. We may think it's the solution. Next, let's create another *BigDecimal* object:

`BigDecimal BD2 = new BigDecimal("0.0000");`

Apparently, the *BD2* object's value is zero, although we've constructed it by a string with a scale of four. As we all know, 0.0000 is the same as 0 in value.

Now, let's test BD2 with the *equals* method again:

`assertThat(BigDecimal.ZERO.equals(BD2)).isTrue();`

This time, if we run the method, **surprisingly, the test will fail**.

This is because a *BigDecimal* object has value and scale attributes. Moreover, **the equals method considers two BigDecimal objects equal only if they are equal in both value and scale**. That is to say,

*BigDecimal*42 is not equal to 42.0 if we compare them with

*equals*.

On the other side, the *BigDecimal.ZERO* constant has the value zero and a scale of zero, too. So, when we check “*0 equals 0.0000*“, the *equals* method returns *false*.

Therefore, we need to find a way only to compare two *BigDecimal* objects' values but ignore their scales.

Next, let's see a couple of approaches to solve the problem.

## 4. Using the *compareTo* Method

The *BigDecimal* class implements the *Comparable* interface. So, we can use the *compareTo* method to compare two *BigDecimal* objects' values.

Further, the *compareTo* method's Javadoc clearly states:

Two

BigDecimalobjects that are equal in value but have a different scale (like 2.0 and 2.00) are considered equal by this method.

Therefore, **we can check BigDecimal.ZERO.compareTo(givenBdNumber) == 0** to decide if givenBdNumber has the value zero.

Next, let's test if this method can correctly tell if both *BigDecimal* objects *BD1* and *BD2* are zero:

```
assertThat(BigDecimal.ZERO.compareTo(BD1)).isSameAs(0);
assertThat(BigDecimal.ZERO.compareTo(BD2)).isSameAs(0);
```

When we run the test, it passes. So, we've solved the problem using the *compareTo* method.

## 5. Using the *signum* Method

**The BigDeicmal class provides the signum method to tell if the given BigDecimal object's value is negative (-1), zero (0), or positive (1)**. The

*signum*method will ignore the scale attribute.

Therefore, we can solve the problem by checking *(givenBdNumber.signum() == 0)*.

Again, let's write a test to verify if this approach works for the two examples:

```
assertThat(BD1.signum()).isSameAs(0);
assertThat(BD2.signum()).isSameAs(0);
```

The test above passes if we give it a run.

## 6. Conclusion

In this short article, we've addressed two proper ways to check if a *BigDecimal* object's value is zero: the *compareTo* method or the *signum* method.

As usual, the complete code of this article can be found over on GitHub.