**I just announced the new *** Learn Spring * course, focused on the fundamentals of Spring 5 and Spring Boot 2:

*Learn Spring*course, focused on the fundamentals of Spring 5 and Spring Boot 2:

**>> CHECK OUT THE COURSE**

Last modified: September 17, 2020

In this short article, we're going to look at how to round a number to *n* decimal places in Java.

Learn different ways of getting the number of digits in an Integer in Java.

Learn how to check the primality of the number using Java.

Explore different ways to determine whether a String is numeric or not.

Java provides two primitive types that can be used for storing decimal numbers: *float* and *double*. *Double* is the type used by default:

`double PI = 3.1415;`

However, both types **should never be used for precise values**, such as currencies. For that, and also for rounding, we can use the *BigDecimal* class.

If we just want to print a decimal number with *n* digits after decimal point, we can simply format the output String:

```
System.out.printf("Value with 3 digits after decimal point %.3f %n", PI);
// OUTPUTS: Value with 3 digits after decimal point 3.142
```

Alternatively, we can format the value with the *DecimalFormat *class:

```
DecimalFormat df = new DecimalFormat("###.###");
System.out.println(df.format(PI));
```

*DecimalFormat* allows us to explicitly set rounding behavior, giving more control of the output than *String.format()* used above.

To round *double*s to *n* decimal places, we can write a **helper method**:

```
private static double round(double value, int places) {
if (places < 0) throw new IllegalArgumentException();
BigDecimal bd = new BigDecimal(Double.toString(value));
bd = bd.setScale(places, RoundingMode.HALF_UP);
return bd.doubleValue();
}
```

There is one important thing to notice in this solution – when constructing *BigDecimal*; we must **always use BigDecimal(String) constructor**. This prevents issues with representing inexact values.

We can achieve the same by using the Apache Commons Math library:

```
<dependency>
<groupId>org.apache.commons</groupId>
<artifactId>commons-math3</artifactId>
<version>3.5</version>
</dependency>
```

The latest version can be found here.

Once the library is added to the project, we can use the *Precision.round()* method, which takes two arguments – value and scale:

`Precision.round(PI, 3);`

By default, it is using the same *HALF_UP* rounding method as our helper method. Therefore, the results should be the same.

Note that we can change rounding behavior by passing the desired rounding method as a third parameter.

*DoubleRounder* is a utility in the decimal4j library. It provides a fast and garbage-free method for rounding doubles from 0 to 18 decimal points.

We can get the library (the latest version can be found here) by adding the dependency to the *pom.xml*:

```
<dependency>
<groupId>org.decimal4j</groupId>
<artifactId>decimal4j</artifactId>
<version>1.0.3</version>
</dependency>
```

Now, we can simply use:

`DoubleRounder.round(PI, 3);`

However, *DoubleRounder* fails in a few scenarios, for example:

```
System.out.println(DoubleRounder.round(256.025d, 2));
// OUTPUTS: 256.02 instead of expected 256.03
```

Another way of rounding numbers is to use Math.Round() Method.

In this case, we can control *n* number of decimal places by multiplying and dividing by *10^n*:

```
public static double roundAvoid(double value, int places) {
double scale = Math.pow(10, places);
return Math.round(value * scale) / scale;
}
```

**This method is not recommended as it's truncating the value**. In many cases values are rounded incorrectly:

```
System.out.println(roundAvoid(1000.0d, 17));
// OUTPUTS: 92.23372036854776 !!
System.out.println(roundAvoid(260.775d, 2));
// OUTPUTS: 260.77 instead of expected 260.78
```

And so, this method is listed here for learning purposes only.

In this quick tutorial, we covered different techniques for rounding numbers to *n* decimal places.

We can simply format the output without changing the value, or we can round the variable by using a helper method. We've also covered a few libraries that deal with this problem.

The code used during the discussion can be found over on GitHub.

There is a wrong character in the code example: if (places < 0)