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

*Learn Spring*course:

**>> CHECK OUT THE COURSE**

Last modified: May 11, 2021

In this short tutorial, we'll learn 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 we can use for storing decimal numbers: *float* and *double*. *Double* is the default type:

`double PI = 3.1415;`

However, we **should never use either type 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 the 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 the *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 result 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 we add the library 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:

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

Another way of rounding numbers is to use the* 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
```

As a result, this method is listed here for learning purposes only.

In this article, 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 also discussed a few libraries that deal with this problem.

The code used in this article can be found over on GitHub.

1 Comment

Oldest

Follow the Java Category

Follow the Java category to get regular info about the new articles and tutorials we publish here.