## 1. Overview

Integer and BigDecimal are two commonly used number types in our day-to-day Java programming.

In this quick tutorial, we’ll explore how to multiply a BigDecimal number by an Integer number.

## 2. Introduction to the Problem

An example can explain the problem quickly. Let’s say we have a BigDecimal number and an integer:

``````final BigDecimal BIG = new BigDecimal("42.42");
final int INT = 10;``````

Then we want to calculate the result of 42.42 x 10 as another BigDecimal number:

``final BigDecimal EXPECTED = new BigDecimal("424.2");``

BigDecimal provides a set of math calculation methods such as add(), divide(), subtract(), multiply(), and so on. These methods allow us to perform standard arithmetic calculations conveniently. However, we should note that these methods can only do the math between two BigDecimal objects. In other words, they only accept arguments in BigDecimal type.

Therefore, we can’t multiply a BigDecimal directly by an Integer.

Next, let’s see how we can perform the calculation. For simplicity, we’ll use unit test assertions to verify if the solution produces the expected result.

## 3. Converting Integer Into a BigDecimal Instance

Now we understand that BigDecimal.multiply() only accepts BigDecimal number as the argument. So, if we can convert the Integer object into a BigDecimal object, we can perform the multiplication calculation.

The BigDecimal class has the valueOf() method, which allows us to get a BigDecimal number from an Integer:

``````BigDecimal result = BIG.multiply(BigDecimal.valueOf(INT));

assertEquals(0, EXPECTED.compareTo(result));``````

The test passes if we give it a run. So we’ve got the expected result.

It’s worth mentioning that apart from the BigDecimal.valueOf(INT) method, we could get a BigDecimal number from Integer using the constructor: new BigDecimal(INT).

However, using the valueOf() method is preferred. This is because the BigDecimal class has predefined eleven commonly used instances: zero through ten:

``````ZERO_THROUGH_TEN = new BigDecimal[]{new BigDecimal(BigInteger.ZERO, 0L, 0, 1),
new BigDecimal(BigInteger.ONE, 1L, 0, 1),
new BigDecimal(BigInteger.TWO, 2L, 0, 1),
new BigDecimal(BigInteger.valueOf(3L), 3L, 0, 1),
...
new BigDecimal(BigInteger.TEN, 10L, 0, 2)};
``````

The valueOf() method checks if the given integer is in the “zero through ten” range and tries to reuse the predefined instance. On the other hand, calling the constructor always creates a new BigDecimal instance.

## 4. A Word About the Assertion

We’ve written a test, and it has verified our solution works. However, curious eyes may see the assertion looks a bit awkward:

``assertEquals(0, EXPECTED.compareTo(result));``

Some of us might want to simplify it for better readability:

``assertEquals(EXPECTED, result);``

However, if we run the test with the assertion above, the test fails:

``````org.opentest4j.AssertionFailedError:
Expected :424.2
Actual   :424.20``````

This is because BigDecimal‘s equals() method doesn’t only compare the two BigDecimal numbers’ values, it also checks the two BigDecimal number’s scale:

``````public boolean equals(Object x) {
if (x instanceof BigDecimal xDec) {
if (x == this) {
return true;
} else if (this.scale != xDec.scale) {
return false;
} else {
...
}``````

In our case, we are only interested in the BigDecimal number’s value. Therefore, we need to call the compareTo() method.

Alternatively, we can use AssertJ‘s isEqualByComparingTo() method to make the code easier to read:

``assertThat(result).isEqualByComparingTo(EXPECTED);``

## 5. Conclusion

In this article, we’ve learned how to multiply BigDecimal by an Integer. As the BigDecimal.multiply() only accepts a BigDecimal object as the argument, we need to convert the Integer object into a BigDecimal instance before calling the multiply() method.

As usual, all code snippets presented in the article are available over on GitHub.

### Get started with Spring 5 and Spring Boot 2, through the Learn Spring course:

>> CHECK OUT THE COURSE