How to round a number to n decimal places in Java ?

To round a number to ( n ) decimal places in Java, you can use several approaches depending on your precision needs and rounding mode requirements. Below are detailed methods with examples:

1. Using Math.round() with Scaling

Best for: Simple rounding with HALF_UP behavior (casual use, not for precise financial calculations).
Steps:

1. Multiply the number by ( 10^n ).
2. Apply Math.round().
3. Divide by ( 10^n ).

public static double roundUsingMath(double value, int places) {
    if (places < 0) throw new IllegalArgumentException("Places must be non-negative.");
    double factor = Math.pow(10, places);
    return Math.round(value * factor) / factor;
}

// Example
double num = 3.14159;
double rounded = roundUsingMath(num, 2); // 3.14

Limitations:

• Precision issues with doubles (e.g., roundUsingMath(2.675, 2) returns 2.67 due to double imprecision).
• Uses HALF_UP rounding implicitly but may not handle edge cases correctly.

2. Using BigDecimal for Precise Rounding

Best for: Financial calculations or when exact rounding is required.
Steps:

1. Convert the number to a BigDecimal (use String constructor to avoid double imprecision).
2. Set the scale with desired rounding mode.
3. Convert back to double if needed.

import java.math.BigDecimal;
import java.math.RoundingMode;

public static double roundUsingBigDecimal(double value, int places) {
    if (places < 0) throw new IllegalArgumentException("Places must be non-negative.");
    BigDecimal bd = new BigDecimal(Double.toString(value));
    bd = bd.setScale(places, RoundingMode.HALF_UP);
    return bd.doubleValue();
}

// Example
double num = 2.675;
double rounded = roundUsingBigDecimal(num, 2); // 2.68

Key Notes:

• Always use new BigDecimal(String) to avoid double precision errors.
• Supports all rounding modes (e.g., HALF_UP, HALF_DOWN, CEILING).

3. Using DecimalFormat for String Formatting

Best for: Formatting numbers as strings for display.
Steps:

1. Define a pattern with # for optional digits and 0 for required digits.
2. Set the rounding mode.
3. Format the number.

import java.text.DecimalFormat;
import java.math.RoundingMode;

public static String roundUsingDecimalFormat(double value, int places) {
    if (places < 0) throw new IllegalArgumentException("Places must be non-negative.");
    StringBuilder pattern = new StringBuilder("#.");
    for (int i = 0; i < places; i++) pattern.append("#");
    DecimalFormat df = new DecimalFormat(pattern.toString());
    df.setRoundingMode(RoundingMode.HALF_UP);
    return df.format(value);
}

// Example
double num = 3.14159;
String roundedStr = roundUsingDecimalFormat(num, 3); // "3.142"

Limitations:

• Returns a String, not a numeric type.
• Parsing back to double may reintroduce precision issues.

4. Handling Edge Cases

Negative Numbers

// Using BigDecimal
BigDecimal bd = new BigDecimal("-2.675");
bd = bd.setScale(2, RoundingMode.HALF_UP); // -2.68

// Using Math.round()
double rounded = roundUsingMath(-2.675, 2); // -2.67 (due to double imprecision)

Zero Decimal Places

double num = 123.456;
double rounded = roundUsingMath(num, 0); // 123.0

Summary Table

Method	Precision	Returns	Rounding Mode Control	Use Case
Math.round()	Low	double	No	Casual rounding
BigDecimal	High	double	Yes	Financial calculations
DecimalFormat	Medium	String	Yes	Display formatting

Key Takeaways

• For Casual Use: Math.round() with scaling is quick but has precision limitations.
• For Precision: BigDecimal ensures accurate results, especially with String input.
• For Display: DecimalFormat formats numbers into strings with controlled rounding.

By choosing the appropriate method, you can round numbers effectively in Java!