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