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 BigDecimal objects 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.
