math rounding in java

Learn Java practically and Get Certified .

Popular Tutorials

Popular examples, reference materials, learn java interactively, java math methods.

• Java Math.abs()
• Java Math.acos()
• Java Math.addExact()
• Java Math.asin()
• Java Math.atan()
• Java Math.cos()
• Java Math.sin()
• Java Math.tan()
• Java Math.sinh()
• Java Math.cosh()
• Java Math.tanh()
• Java Math.sqrt()
• Java Math.cbrt()
• Java Math.pow()
• Java Math.subtractExact()
• Java Math.multiplyExact()
• Java Math.incrementExact()
• Java Math.decrementExact()
• Java Math.negateExact()
• Java Math.toIntExact()
• Java Math.min()
• Java Math.max()
• Java Math.ceil()
• Java Math.floor()
• Java Math.round()
• Java Math.toRadians()
• Java Math.toDegrees()
• Java Math.atan2()
• Java Math.copySign()
• Java Math.exp()
• Java Math.expm1()
• Java Math.getExponent()
• Java Math.hypot()
• Java Math.IEEEremainder()
• Java Math.log()
• Java Math.log10()
• Java Math.log1p()
• Java Math.nextAfter()
• Java Math.nextUp()
• Java Math.nextDown()
• Java Math.rint()

Java Math.random()

Java Tutorials

Java Math floor()

Java Math ceil()

Java Math rint()

• Java Math abs()
• Java Math max()

Java Math round()

The round() method rounds the specified value to the closest int or long value and returns it. That is, 3.87 is rounded to 4 and 3.24 is rounded to 3 .

Syntax of Math.round()

The syntax of the round() method is:

Here, round() is a static method. Hence, we are accessing the method using the class name, Math .

round() Parameters

The round() method takes a single parameter.

• value - number which is to be rounded

Note : The data type of the value should be either float or double .

round() Return Value

• returns the int value if the argument is float
• returns the long value if the argument is double

The round() method:

• rounds upward if the value after the decimal is greater than or equal to 5 1.5 => 2 1.7 => 2
• rounds downward if the value after the decimal is smaller than 5 1.3 => 1

Example 1: Java Math.round() with double

Example 2: java math.round() with float.

Sorry about that.

Related Library Functions

Java Library

Round off in Java

Round off is a term in mathematics that refers to the conversion of a decimal value to the nearest integer value.

Math.round() is one of the many built-in Java methods that allows you to round a floating-point number to the nearest whole number.

• It takes a single argument of type double or float .
• It returns the rounded value as a long or an int , respectively.
• If the fractional part of the number is less than 0.5, it rounds down. If it's 0.5 or greater, it rounds up.

Introduction to Math.round() in java

Round off is used to convert decimal values to integer values for ease of calculations or according to the need of calculation. Values are rounded off to their nearest integer. These values can either be rounded off to a higher integer or a lower integer. If the decimal value is greater than 0.5 then the decimal value will be rounded off to its higher value and if the decimal value is less than 0.5 then it will be rounded off to its lower value.

Lets's see some simple examples to see how we round off normally in mathematics:

1 . 7 8 1.78 1 . 7 8 = 2 2 2

2 . 7 6 8 8 6 7 8 2.7688678 2 . 7 6 8 8 6 7 8 = 3 3 3

− 1 . 2 3 4 7 7 -1.23477 − 1 . 2 3 4 7 7 = − 1 -1 − 1

Primitive data types are data types that are not considered objects and represent variables. Most of the variables we declare are of primitive data types in java.

There are 8 primitive data types in Java: int , byte , short , long , float , double , boolean , and char . In this article, we will focus on two primitives: float and double .

Both float and double are floating-point types that store fractional numbers, i.e., decimal numbers containing one or more decimals.

• The float data type can store fractional numbers in range 3.4e-038 to 3.4e+038 .
• The precision of float is only six or seven decimal digits .
• The double data type can store fractional numbers in the range 1.76-308 to 1.7e+308 .
• The precision of double is up to 15 digits . Hence, double is preferred when accuracy is needed .

Different ways to Round Off in Java

There are different ways provided by Java libraries to round off floating numbers. Some of these methods are part of the java.lang.Math class. However, there are other approaches that can be used for rounding off in Java without using Math class methods.

Java has a predefined class in its java.lang package known as the Math class , which deals with mathematical calculations. The java.lang.Math class extends the java.lang.Object class, which is a superclass in Java. It contains methods for performing basic numeric operations such as logarithm, square root, trigonometric functions, etc.

1. Using Math.ceil() method

The java.lang.Math.ceil() method is used to find the nearest integer value that is greater than or equal to the number given as an argument.

ceil(1.2656) = 2

ceil(6876.677) = 6877

ceil(-0.897) = -0

b. Parameter

The Math.ceil() method takes a double variable as an argument/parameter.

This method returns the nearest floating-point value that is greater than or equal to the number given as an argument to the method.

• If the argument is Not a Number (NaN) , this method will return the argument itself .
• If the argument is positive or negative Infinity , this method will return Infinity value with the same sign .
• If the argument is zero , this method will return 0 .
• If the argument is a number less than 0 but greater than -1.0 , this method will return -0 .
• If the argument is a positive or negative double value , this method will return the ceiling value , i.e., the nearest value that is greater than or equal to the argument.

Notes: Even though the Math.ceil() method rounds off the argument, the data type of the output will be a double that's equal to its mathematical integer value. You can remember this by comparing it to the ceiling of your room. A ceiling is at a higher level. The output of the Math.ceil() function will give the upper/greater number as an output.

2. Using Math.floor() method

The java.lang.Math.floor() method is used to find the nearest integer value that is less than or equal to the number given as an argument.

c i e l ( 1 . 2 6 5 6 ) ciel(1.2656) c i e l ( 1 . 2 6 5 6 ) = 1 1 1

c i e l ( 6 8 7 6 . 6 7 7 ) ciel(6876.677) c i e l ( 6 8 7 6 . 6 7 7 ) = 6 8 7 6 6876 6 8 7 6

c i e l ( − 0 . 8 9 7 ) ciel(-0.897) c i e l ( − 0 . 8 9 7 ) = − 1 -1 − 1

b. Parameter The Math.floor() method takes double variable as an argument/parameter.

c. Returns This method returns the nearest floating-point value that is less than or equal to the number given as an argument to the method.

• If the argument Not a Number(NaN) , this method will return argument itself .
• If the argument is +ve/-ve Infinity , this method will return Infinity with the same sign .
• If the argument is +ve/-ve Zero , this method will return 0 with the same sign .
• If the argument is a number less than 0 but greater than -1.0 , this method will return -1 .
• If the argument is +ve or -ve double value , this method will return floor value i.e. nearest value that is less than or equal to the argument.

Notes: Even though Math.floor() method rounds off the argument, the datatype of output will be double that's equal to its mathematical integer value. You can remember this by comparing it to the floor of your room. As the floor is downside/at a lower level, the output of Math.floor() function will give a lower/smaller number as an output.

3. Using Math.round() method

The java.lang.Math.round() method in Java is used to round off decimal numbers to their nearest integer value. This integer value can be either higher or lower than the decimal value being rounded off. This method takes both float and double variables as arguments.

The result of rounding the argument to an integer is calculated by adding 1/2 (i.e., 0.5 ) to the number and then taking the floor of the result. This determines the nearest integer value that is closer to the argument.

Let's understand it with some examples:

Example 1: Round off 8.76

• Step 1: Add 0.5 to the floating number.

8.76 + 0.5 = 9.26

• Step 2: Take the floor of the value obtained after adding 1/2.

Math.floor(9.26) = 9

• Step 3: Answer

Math.round(8.76) = 9

Example 2: Round off 1.2

1.2 + 0.5 = 1.70

Math.floor(1.70) = 1

Math.round(1.2) = 1

b. Parameter The Math.round() method takes floating-point numbers, i.e., both float and double data types, as arguments.

c. Returns This method returns the nearest integer value as an output. It is calculated by adding 1/2 to the argument and then taking the floor of the result.

• If the argument is Not a Number (NaN) , this method will return zero .
• If the argument is negative infinity or any value less than or equal to the value of Integer.MIN_VALUE , then the function returns Integer.MIN_VALUE .
• If the argument is positive infinity or any value greater than or equal to the value of Integer.MAX_VALUE , then the function returns Integer.MAX_VALUE .
• If the argument is a positive or negative number , this method will return the nearest value . The output can be higher or lower than the argument passed, depending on which value is closer.

Notes: This method takes both float and double values as arguments. In the case of float argument, the data type of output is int. In the case of a double argument, the data type of output is long.

Short trick: You can remember this using a short trick. If the decimal value of a positive argument is greater than 0.5 , then it will return the nearest number greater than the argument as the output.

Example: 9.8 will be rounded off to 10 .

If the decimal value of a positive argument is less than 0.5 , then it will return the nearest number smaller than the argument as the output.

Example: 9.2 will be rounded off to 9 .

Note: The above trick is for positive numbers; it will be vice versa for negative numbers.

4. Using format

Apart from using the Math class in Java, there are other ways to round a number. One of those methods is the format() method in Java. This method returns the formatted string in the given format and is one of the easiest ways to format output in Java.

To use this method, we can use the System.out.format() statement for output formatting in Java. Similar to the printf statements in C language, we can specify the format of the output using %c , %f , %d , etc. For example, %f stands for a floating-point number, and we can provide precision for the decimal value using %.4f , which means the output should be a floating-point number rounded to 4 decimal places.

In the Java String format() method, we can specify the format in which the output is expected. Now, let's see how we can use this method to round off a floating-point number in Java.

In the above program, the format() method is used to print the given floating-point number number to 2 decimal places. The format of the output is specified to the format() method using the format .2f .

In this format, the .2 specifies that we want to display up to 2 decimal places after the dot, and f indicates that we want to print a floating-point number.

5. Using DecimalFormat

DecimalFormat is a subclass of the NumberFormat class in Java. NumberFormat extends the Format class, which is a subclass of the Object class in Java. The hierarchy of the DecimalFormat class can be seen in the provided image.

The java.text.DecimalFormat class is used to format floating-point values according to specific patterns. The format of the expected output is defined using # patterns.

When creating an object of the DecimalFormat class, we specify a pattern using # , which represents the format of the expected output. For example, if the pattern is #.## , it means that the given argument should be rounded off to 2 decimal places. The last decimal place is rounded using the CEILING mode of the RoundingMode class.

Here's an example program that demonstrates the usage of DecimalFormat:

In the above program, the number num1 is rounded off using the DecimalFormat class. The format of the required output is declared using the # pattern ( #.#### ). This means we want num1 up to 4 decimal places. The rounding mode is set to CEILING , indicating that the last given decimal place should be rounded up.

So, 1087.12345567 rounded to 4 decimal places is 1087.1234 , and the last decimal place ( 4 ) is rounded up using the CEILING mode, resulting in 5 . Hence, the output is 1087.1235 .

Note: We need to import the DecimalFormat and RoundingMode classes in Java using the import statement, as they are not part of the default java.lang package.

• Round-off is used to convert decimal values into integers.
• The java.lang.Math class has Math.ceil() , Math.floor() , and Math.round() methods to round off floating-point values.
• Math.ceil() and Math.floor() explicitly convert the decimal value to higher and lower integer values, respectively. They are used in complex calculations where accuracy is required.
• Math.round() converts the decimal value to a higher or lower integer value, whichever is nearest.
• The String format method can be used to round off decimal values up to a desired number of decimal places.
• The java.text.DecimalFormat class, which is a subclass of java.text.NumberFormat , can be used to format floating-point values into a specific format with the help of RoundingMode .

• Java Arrays
• Java Strings
• Java Collection
• Java 8 Tutorial
• Java Multithreading
• Java Exception Handling
• Java Programs
• Java Project
• Java Collections Interview
• Java Interview Questions
• Spring Boot
• Java Program to Find GCD or HCF of Two Numbers
• How to Find the Volume of a Tetrahedron Using Determinants in Java?
• Local Variable Type Inference or LVTI in Java 10
• Encrypt and Decrypt Image using Java
• Java Program to convert integer to boolean
• Java Program to Get the Size of a Directory
• Getter and Setter in Java
• Java Program to Demonstrate the Call By Value
• Java Program to Show the Nesting of Methods
• Java program to count the occurrences of each character
• How to Generate Unique Positive Long Number in Java?
• Java Program to Convert Binary String to Decimal Using Wrapper Class
• Program to convert first character uppercase in a sentence
• Java Program To Find Largest Between Three Numbers Using Ternary Operator
• Java Program to Add Two Matrix Using Iterative Approach
• Java Program For Hexadecimal to Decimal Conversion
• Java Program to Find the Largest of three Numbers
• Java Program to Convert String to Long
• Java Program to Add Two Numbers

Java Program to Round a Number to n Decimal Places

Floating-point numbers are decimal values, which can be rounded to n number of decimal places. There are 3 different ways to Round a Number to n Decimal Places in Java as follows: 

• Using format Method
• Using DecimalFormat Class
• Multiply and Divide the number by 10 n (n decimal places)

Method 1: Using format Method

The decimal number can be rounded by the inbuilt format() method supported by Java. 

Syntax: 

Parameters: The first parameter accepts d digits to round off the number, the second argument accepts a number that is to be rounded.

Method 2: Using DecimalFormat Class 

DecimalFormat is a child class of the NumberFormat which is used to perform formatting of decimal numbers in java. We create an object of this class and pass in as arguments the format specified in form of #, with the number of # after decimal point indicating the number of digits we wish to output. By default, the number is rounded off to the ceiling value itself. The object of the DecimalFormat class invokes a method format() which takes as argument the number to be formatted.

Note: In case we wish to round off the number to the floor, we invoke the Java in-built class RoundingMode . It has the following values for attributes as follows: FLOOR – for next nearest floor value CEILING – for next nearest ceiling value

Also do remember, this method can be invoked on the DecimalFormat class supported in-built method setRoundingMode(), which takes as an argument either RoundingMode.FLOOR or CEILING, and accordingly gives us the result.

Method 3: Multiply and Divide the number with 10 n (n decimal places)

 In this approach, we first Multiply the number by 10 n using the pow() function of the Math class. Then the number is rounded to the nearest integer. At last, we divide the number by 10 n . By doing this, we get the decimal number up to n decimal places.

Please Login to comment...

• How to Delete Whatsapp Business Account?
• Discord vs Zoom: Select The Efficienct One for Virtual Meetings?
• Otter AI vs Dragon Speech Recognition: Which is the best AI Transcription Tool?
• Google Messages To Let You Send Multiple Photos
• 30 OOPs Interview Questions and Answers (2024)

Improve your Coding Skills with Practice

What kind of Experience do you want to share?

How To Round In Java: Straightforward Steps

Rounding in Java is more than just Math.round(). Different scenarios demand distinct techniques. This article offers clear guidance on Java's various rounding methods, ensuring precision and efficiency in your coding tasks.

KEY INSIGHTS

• Java's Math class offers versatile methods like `ceil()`, `floor()`, and `round()` for different rounding scenarios.
• The `DecimalFormat` class allows advanced control over floating-point number formatting, with customizable patterns.
• `BigDecimal` is ideal for high-precision calculations in domains like finance, featuring various rounding modes.
• Choosing the right rounding method depends on context and requirements, considering accuracy, speed, and domain-specific needs.

Rounding numbers is a fundamental task in many programming scenarios. In Java, various methods can help you achieve this efficiently. Let's explore the best techniques to round numbers in this widely-used programming language.

Understanding Java's Math Class

Basic rounding: math.round(), rounding floating-point numbers: decimalformat, rounding up and down: math.ceil() and math.floor(), bigdecimal for precise rounding, choosing the right rounding strategy, frequently asked questions, java math class basics, common methods in math class, rounding in the math class.

The Java Math class is one of the core classes in Java and is part of the java.lang package. This class provides numerous methods for performing basic numeric operations.

The Math class is static, which means you cannot instantiate an object of the Math class. Instead, you call its methods directly.

The Math class provides a plethora of methods that aid in various mathematical operations. Here are some commonly used methods:

• abs() : Returns the absolute value.
• ceil() : Rounds up to the nearest whole number.
• floor() : Rounds down to the nearest whole number.
• round() : Rounds to the nearest whole number.

When it comes to rounding, the Math class offers a direct method: round() . This method operates by adding 0.5 to the number and then flooring it.

Remember, the Java Math class is a powerful tool that encompasses various methods, making numerical operations more accessible and efficient. Whether you're performing basic arithmetic or advanced calculations, this class is fundamental to achieving accurate results in Java.

Syntax And Return Type

Behavior of rounding, considerations for negative numbers.

The Math.round() method is a fundamental tool in Java for rounding floating-point numbers to the nearest whole number. Its behavior is simple: if the decimal part is 0.5 or above, it rounds up; otherwise, it rounds down.

The Math.round() method comes in two variations: one for floating-point numbers of type float and another for double .

It's essential to grasp the rounding behavior . As stated, if the decimal part of the number is 0.5 or more, it rounds up; otherwise, it rounds down.

Rounding negative numbers might seem tricky, but Math.round() handles them predictably. The method still uses the 0.5 threshold but rounds towards 0.

In essence, the Math.round() method in Java offers a direct and reliable way to round numbers. It's vital to be mindful of its behavior, especially when dealing with decimals close to the 0.5 threshold or negative numbers. This ensures that your rounding operations yield expected results every time.

Setting Up DecimalFormat

Patterns in decimalformat, rounding modes with decimalformat.

When you need precision and control over the rounding of floating-point numbers, the DecimalFormat class from the java.text package steps in. This class allows you to format numbers based on patterns and provides enhanced rounding capabilities.

To use the DecimalFormat class, you first need to create an instance by providing a pattern string that dictates the desired format.

The pattern strings dictate how the number should be formatted. Some common symbols in the patterns include:

• # : Represents a digit and will not display zeros.
• 0 : Displays zeros if no digit is present in that location.

The DecimalFormat class also allows you to specify rounding modes. This is invaluable when you need to follow certain rounding rules or standards.

To conclude, the DecimalFormat class is a versatile tool for formatting and rounding floating-point numbers in Java. With its pattern strings and customizable rounding modes, it offers developers granular control over number formatting, ensuring precise outcomes tailored to specific requirements.

Always Rounding Up: Math.ceil()

Always rounding down: math.floor().

While Math.round() provides general rounding capabilities, sometimes you might require definitive control, specifically to always round up or always round down. For these tasks, Java offers two essential methods: Math.ceil() for rounding up and Math.floor() for rounding down.

The Math.ceil() function takes in a floating-point number and returns the smallest integer that is greater than or equal to the provided number.

The counterpart to Math.ceil() , the Math.floor() function returns the largest integer that is less than or equal to the given number.

When using Math.ceil() and Math.floor() with negative numbers, it's crucial to understand their behavior to ensure accurate results.

For scenarios where specific rounding control is necessary, Math.ceil() and Math.floor() are invaluable tools. By understanding their distinct behaviors, you can ensure that your numbers are rounded accurately and consistently in Java applications.

Initializing BigDecimal

Rounding with bigdecimal, common rounding modes, arithmetic with bigdecimal.

When dealing with financial calculations or scenarios that demand extreme precision, the built-in Java data types might not suffice. In such cases, BigDecimal emerges as the hero. It provides excellent control over rounding modes and guarantees accuracy.

Before you can perform any operations, you'll need to initialize a BigDecimal instance. This can be done using its constructor which accepts a string representation of the number.

The setScale() method, when combined with rounding modes, offers precision rounding.

There are several rounding modes available with BigDecimal , some of which include:

• RoundingMode.HALF_UP : Rounds towards the "nearest neighbor" unless both neighbors are equidistant, in which case it rounds up.
• RoundingMode.DOWN : Rounds towards zero.
• RoundingMode.UP : Rounds away from zero.

When using BigDecimal , arithmetic operations aren't as straightforward as with primitive data types. Instead of using + , - , etc., you'll utilize methods like add() , subtract() , and multiply() .

The BigDecimal class in Java ensures accurate and precise numerical operations, especially beneficial in scenarios where standard floating-point operations might introduce errors. It's the tool of choice when precision is paramount.

Context Is Key

Common rounding strategies, factors to consider.

Rounding numbers is more than just a mechanical process. The method you choose can have significant implications, especially in contexts like financial calculations, statistics, and scientific computations. Picking the right rounding strategy is thus crucial.

The first step in selecting an appropriate strategy is understanding the context. Are you dealing with financial transactions where precision is paramount, or are you working in a domain where an approximation is acceptable? Your decision should lean heavily on the specific requirements of your project.

Here's a look at some of the standard methods available in Java:

1. Half Up: This is perhaps the most intuitive method. If the digit is 5 or higher, you round up.

2. Half Down: In this strategy, if the number is exactly 0.5, it's rounded down.

3. Ceiling: This method always rounds up, moving away from zero.

4. Floor: Conversely, the floor method always rounds down, moving towards zero.

When deciding on a rounding strategy, keep in mind:

• Accuracy vs. Speed: Some methods are faster but may offer less precision.
• Domain Requirements: Financial systems often have strict requirements around rounding, while others may be more lenient.
• Stakeholder Expectations: Always consider the expectations of end-users or other stakeholders. They might have preferences based on industry standards or past experiences.

Choosing the right rounding strategy is essential for the integrity of your computations. By understanding the available methods and the contexts in which they're most effective, you can make informed decisions that enhance the accuracy and credibility of your work.

Why would I use BigDecimal over the built-in rounding methods?

BigDecimal is designed for high precision, making it preferable in scenarios like financial calculations where exactness is paramount. Its setScale() method provides flexibility in defining both the number of decimal places and the rounding mode.

Are there performance implications when choosing one rounding method over another?

Generally, the performance difference between various rounding methods is negligible for everyday tasks. However, in high-performance applications or situations with a vast number of calculations, using simpler rounding methods might offer a speed advantage.

Can I create a custom rounding method in Java?

Yes, you can. While Java provides several built-in methods, you can always implement custom logic to suit specific needs. This often involves conditional statements and arithmetic operations.

When using Math.ceil() and Math.floor() , is there a risk of losing precision?

Both Math.ceil() and Math.floor() will provide exact results as they always round up or down to the nearest whole number. The main thing to be aware of is that you're making a conscious decision to always round in one specific direction.

Why does Java offer so many rounding options?

Different applications have different requirements. For instance, a banking system might need high precision, while a graphical application might prioritize speed. Java offers multiple methods to cater to a wide range of needs.

Let’s test your knowledge!

Which Java Method Rounds Up A Number To The Nearest Whole Value?

Continue learning with these java guides.

• How To Install Java On Windows 10: Step-By-Step Instructions
• How To Make A Game With Java: Step-By-Step Instructions
• What Is The Modulo Operator (%) In Java And How To Use It
• How To Make A GUI In Java: Step-By-Step Approach
• What Is Java Boolean And How To Use It
• HashMap In Java: Advantages, Limitations, And Best Practices

Subscribe to our newsletter

Subscribe to be notified of new content on marketsplash..

• Help Center Home
• API Documentation
• Related Resources

JDK 22 Documentation

Java Components page

Looking for a different release? Other releases

• Release Notes
• Migration Guide
• Download the JDK
• Installation Guide
• Version-String Format

• JDK Tool Specifications
• JShell User's Guide
• JavaDoc Guide
• Packaging Tool User Guide

Language and Libraries

• Language Updates
• Core Libraries
• JDK HTTP Client
• Java Tutorials
• Modular JDK
• Flight Recorder API Programmer’s Guide
• Internationalization Guide

Specifications

• Language and VM
• Java Security Standard Algorithm Names
• Java Native Interface (JNI)
• JVM Tool Interface (JVM TI)
• Serialization
• Java Debug Wire Protocol (JDWP)
• Documentation Comment Specification for the Standard Doclet
• Other specifications

• Secure Coding Guidelines
• Security Guide

HotSpot Virtual Machine

• Java Virtual Machine Guide
• Garbage Collection Tuning

Manage and Troubleshoot

• Troubleshooting Guide
• Monitoring and Management Guide

Client Technologies

• Java Accessibility Guide