4 Examples to Round Floating-Point Numbers in Java up to 2 Decimal Places

Rounding numbers up to 2 or 3 decimal places id a common requirement for Java programmer. Thankfully, Java API provides a couple of ways to round numbers in Java. You can round any floating-point numbers in Java unto n places By using either Math.round(), BigDecimal, or DecimalFormat. I personally prefer to use BigDecimal to round any number in Java because of it's convenient API and support of multiple Rounding modes. Also, if you are working in the financial industry, it's best to do a monetary calculation in BigDecimal rather than double as I have discussed in my earlier post about common Java mistakes

One of the important things to keep in mind while rounding numbers is Rounding mode. Rounding mode decides how to round discarded fraction and knowledge of popular rounding modes like HALF DOWN, HALF UP, and HALF EVEN certainly helps.

We have seen some bits to round numbers in How to format numbers in Java using the DecimalFormat, and in this Java article, we will explore a couple of more ways to round numbers unto 2 digits in Java.

Though, if you are new to Java, I suggest you first start learning basics like data types, float vs long, and float vs double before going into tricky topic of rounding numbers in Java. If you need a resource then I highly recommend you join The Complete Java Masterclass course by Tim Buchalaka on Udemy. It's also the most up-to-date course and covers new Java features from recent releases.





4 ways to Round floating-point Numbers in Java 

Without wasting any more of your time, here are 4 different ways of rounding numbers in Java. They use RoundingMode and DecimalFormat class in Java for formatting floating-point numbers and rounding them up to two decimal places.

1. Rounding Modes in Java

An important thing to know before rounding numbers are rounding mode. In general, programmer things that if the least significant digit is less than five, than it will be rounded to the floor, greater than five than towards ceiling, and they get confused when it's equidistant.

Rounding modes decide how the least significant digit should be rounded. The BigDecimal class has a Rounding mode defined as an integer constant, which later replaced by RoundingMode enum from Java 1.5. Here are some of the important RoundingMode to remember :
  1. RoundingMode.HALF_DOWN: round down if both neighbors are equidistant like 2.5 will round to 2.0
  2. RoundingMode.HALF_UP: round up if both neighbors are same distant like 2.5 will round to 3.0
  3. RoundingMode.HALF_EVEN: round towards even neighbor if both neighbors are equidistant like 2.5 will round to 2.0 while 5.5 will round to 6.0
There is a couple of more Rounding mode as well like UP, DOWN, FLOOR, and CEILING, which is also worth knowing. If you want to learn more about floating-point numbers and these concepts, I suggest you join Java Fundamentals: The Java Language course on Pluralsight. It's a great fundamental course for Java developers.

4 Examples to Round  Floating Point Numbers in Java up to 2 Decimal Places



2. Round number to 2 decimal place using BigDecimal

Whenever I need to round a number up to n decimal places, I first think of BigDecimal. Not only BigDecimal allow you to choose RoundingMode, but also it's very easy to round numbers up to any decimal place using BigDecimal methods. Here is an example of rounding number up to 2 decimal places :

float number = BigDecimal.valueOf(digit)
                         .setScale(2, BigDecimal.ROUND_HALF_DOWN)
                         .floatValue();

In setScale(), you can specify the number of decimal places you need to round like to round up to 5 places specify 5. Here we have set scale as 2 because we are rounding up to 2 digits. We have also used rounding mode as ROUND_HALF_DOWN, which is similar to RoundingMode.HALF_DOWN.

Half down rounding mode will round numbers down if the discarded fraction is 0.5. In place of BigDecimal.ROUND_HALF_DOWN, you can also use RoundingMode.HALF_DOWN but just beware that RoundingMode enum was added from Java 5 onwards.

Of course, you know this because Java Enum was introduced in 1.5 version. If you are using Java 1.4, then this is the right way to round number up to 2 decimals in Java. Btw, if you want to learn more about Java Enum and other key concepts, you can also take a look at the Java Programming for Complete Beginners course on Udemy.



3. Round number to 2 digits using DecimalFormat

If you are rounding numbers just for displaying purpose than you should consider using DecimalFormat or String format method class. Though there is nothing wrong with using BigDecimal to round numbers, DecimalFormat seems to be the right class for formatting numbers.

Here is Java code to round a number up to 2 significant digits using DecimalFormat in Java.

DecimalFormat df = new DecimalFormat("#.00");
float number = Float.valueOf(df.format(decimal));

The #.00 is for rounding up to 2 decimal places, if you want to round up to 3 or 4 places, just use #.000 or #.0000 to create DecimalFormat. To know more about formatting numbers, See How to format numbers in Java using DecimalFormat.



4. Round number in Java using Math.round()

The Math.round() was classical ways to round numbers in Java. Though it doesn't provide any API to specify how many digits to round, by using multiplication and division, you can make it round up to n or 2 decimal places.

By the way, this is not the preferred way to round numbers in Java, I prefer BigDecimal, but still, its convenient way to round numbers and works on many cases. Here is How to use Math.round() function to round numbers up to 2 digits in Java.

float rounded = (float) Math.round(number100)/100;

We are multiplying and later dividing by 100 to round up to 2 digits if you need to round up to 5 decimal places, multiply and divide by 100000.

By the way, it's Java best practice to prefer BigDecimal over Math.round() to round numbers in Java and if you want to learn more of such Java Practices then there is no better book than Effective Java by Joshua Bloch, it's a great book for both beginners and experienced Java developers. Though,  If you have already read that then you can also try Java by Comparison by Simon Harrer and others.

best book for experienced Java developers




Java program to round numbers up to 2 decimal places

Here is a Java program that combines above 3 ways to round any number up to 2 decimal places in Java. You can change program to round up to 3, 4, or any number of digits.

import java.math.BigDecimal; 
import java.math.RoundingMode; 
import java.text.DecimalFormat; 
import java.util.Arrays;
 
  
/** 
  * Java program tor round numbers up to 2 decimal places in Java.
   * This program explains 3 ways to round numbers, including BigDecimal, 
   * Math.round and DecimalFormat class.
   * @author javin paul
   */
 
public class RoundingNumbers {
 
 
 
    public static void main(String args[]) {
  
         //Sample floating point numbers to round upto 2 decimal places
         float[] samples = new float[]{2.123f, 2.125f, 2.127f};
 
   
        //using Match.round() function to round number upto 2 decimal place
         float[] rounded = round(samples);
 
  
        System.out.println("Before rounding, original numbers        : " 
                              + Arrays.toString(samples));
        System.out.println("After rounding using Math.round() method : " 
                              + Arrays.toString(rounded));
 
 
 
        //Using BigDecimal to round a number up to two decimal place
 
        //You can use different rounding modes e.g., HALF_UP, HALF_DOWN,
          and HALF_EVEN with BigDecimal
 
        rounded = roundUsingBigDecimal(samples);
 
 
 
        System.out.println("Before rounding numbers                  : "
                               + Arrays.toString(samples));
 
        System.out.println("After rounding number using BigDecimal   : " 
                               + Arrays.toString(rounded));
 
 
        //DecimalFormat Example to round number to 2 digits
         rounded = roundUsingDecimalFormat(samples);
         System.out.println("Original floating point numbers          : " 
                             + Arrays.toString(samples));
         System.out.println("round numbers with DecimalFormat in Java : "
                              + Arrays.toString(rounded));
   
    }
 
 
    /*
     * round number to 2 decimal place using Math.round
     */
 
    public static float[] round(float[] numbers){
 
        float[] round = new float[numbers.length];
 
        for(int i = 0; i            float number = numbers[i];

                //rounding number to 2 decimal place
                round[i] = (float) Math.round(number100)/100; 
        }
        return round;      
    }
 
    /*
     * round number to 2 decimal place using BigDecimal class
     * BigDecimal here uses ROUND_HALF_DOWN rounding mode
     */
    public static float[] roundUsingBigDecimal(float[] digits){
        float[] result = new float[digits.length];
        for(int f=0; f            float digit = digits[f];
            result[f] = BigDecimal.valueOf(digit)
                                  .setScale(2, BigDecimal.ROUND_HALF_DOWN)
                                  .floatValue();
        }
        return result;
    }
 
    /*
     * rounding number to 2 decimal place using DecimalFormat
     */
    public static float[] roundUsingDecimalFormat(float[] decimals){
        float[] rounded = new float[decimals.length];
        //DecimalFormat to round numbers to 2 decimal place 
        DecimalFormat df = new DecimalFormat("#.00"); 
        for(int i=0; i            float decimal = decimals[i];
            rounded[i] = Float.valueOf(df.format(decimal));
        }
        return rounded;
    } 
 
}
 
Output:
Before rounding, original numbers        : [2.123, 2.125, 2.127]
After rounding using Math.round() method : [2.12, 2.13, 2.13]
Before rounding numbers                  : [2.123, 2.125, 2.127]
After rounding number using BigDecimal   : [2.12, 2.12, 2.13]
Original floating-point numbers          : [2.123, 2.125, 2.127]
round numbers with DecimalFormat in Java : [2.12, 2.12, 2.13]


That's all on How to round a number up to 2 decimal places in Java. We have seen 3 ways to round numbers in Java, like BigDecimal, DecimalFormat, and Math.round(). BigDecimal looks the best way to round numbers because of the convenient API and support of different rounding modes.

Further Learning
The Complete Java Masterclass
Java Fundamentals: The Java Language
Learn Object-Oriented Programming in Java


Other Java and Programming Resources you may like
  • The Complete Java Developer RoadMap (roadmap)
  • 10 Things Java Programmer should learn in 2020 (things)
  • 10 Books Every Programmer Must Read (books)
  • 10 Tools Every Software Developer should know (tools)
  • 5 Courses to Learn Software Architecture in Depth (courses)
  • 10 Courses to learn DevOps in Depth (courses)
  • 10 Tips to Improve Your Programming skill (tips)
  • 20 Libraries Java Programmer Should Know (libraries)
  • Top 10 Programming languages to Learn in 2020 (languages)
  • 10 Courses to learn Java in-depth (courses)
  • 10 Framework and Library Java and Web Developer Should Learn (frameworks)
  • Top 5 Courses to Learn Microservice in Java (course)
Thanks for reading this article so far. If you find this article useful and able to understand essential OOP concepts like overloading, overriding, hiding, shadowing and obscuring them please share with your friends and colleagues on Facebook, Twitter, or Linkedin. If you have any questions or doubt then please drop a note.

P. S. - If you are new into Java Programming world and want to learn Java but looking for a free course then you can also check out this list of 10 Free Java Programming courses for beginners and anyone who wants to learn Java. 

No comments:

Post a Comment

Feel free to comment, ask questions if you have any doubt.