How to Round to N Decimal Places in Java with Half-Up and No Trailing Zeros

By the end of this page, you will understand how Java rounds decimal numbers, why String.format and DecimalFormat behave differently, and how to produce output that uses HALF_UP rounding without unnecessary trailing zeros. You will also see why BigDecimal is often the safest choice for precise decimal formatting.

In Java, rounding a number and formatting a number are related, but they are not exactly the same task.

• Rounding decides what the numeric value becomes.
• Formatting decides how that value is displayed as text.

In this question, you need both:

1. Round to a maximum number of decimal places.
2. Use half-up rounding.
3. Remove trailing zeros from the displayed result.

Half-up rounding

HALF_UP means:

• If the discarded part is less than 5, round down.
• If it is 5 or more, round up.

Examples:

• 1.2344 to 3 decimal places -> 1.234
• 1.2345 to 3 decimal places -> 1.235

This is the style of rounding many people learn first.

Why DecimalFormat matters

DecimalFormat lets you control how a number is displayed.

For example:

• 0.##### means up to 5 decimal places
• trailing zeros are not forced

That makes it a good fit for output like:

Think of rounding like cutting a rope at a marked point.

• The number of decimal places tells you where to cut.
• The next digit tells you whether to move the cut point slightly forward.
• HALF_UP means if the next digit is 5 or more, you always push the value up.

Now think of formatting as deciding how to write the result on a label.

• String.format("%.5f", ...) says: always print exactly 5 digits after the decimal point.
• DecimalFormat("0.#####") says: print up to 5 digits after the decimal point, but do not add extra zeros.

So:

• rounding decides the value
• formatting decides the appearance

Using DecimalFormat with HALF_UP

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

public class Main {
    public static void main(String[] args) {
        DecimalFormat df = new DecimalFormat("0.#####");
        df.setRoundingMode(RoundingMode.HALF_UP);

        System.out.println(df.format(0.912385)); // 0.91239
        System.out.println(df.format(0.912300)); // 0.9123
        System.out.println(df.format(2.0));      // 2
    }
}

Why this works

• 0.##### means:
  • always show at least one digit before the decimal point
  • show up to 5 digits after the decimal point
  • do not show unnecessary trailing zeros
• setRoundingMode(RoundingMode.HALF_UP) changes the default rounding behavior to the one you want

Reusable method

Consider this example:

DecimalFormat df = new DecimalFormat("0.#####");
df.setRoundingMode(RoundingMode.HALF_UP);
String result = df.format(0.912385);
System.out.println(result);

Step-by-step

1. Create the format pattern

new DecimalFormat("0.#####")

This means:

• 0 before the decimal: show at least one digit
• ##### after the decimal: show up to 5 decimal places

2. Set the rounding mode

df.setRoundingMode(RoundingMode.HALF_UP);

Now if the 6th decimal digit affects rounding, Java will round the 5th digit upward when appropriate.

3. Format the number

df.format(0.912385)

The number has 6 decimal places:

• keep first 5:

This pattern appears often in real software whenever numbers must be shown clearly to users.

Common use cases

• Financial displays
  • show tax, discount, or totals with a defined rounding rule
• Reports and dashboards
  • display percentages or calculated values without visual clutter
• Scientific or measurement tools
  • round values for readable output while keeping only meaningful digits
• APIs generating text output
  • convert computed decimal values into strings for logs, exports, or CSV files
• UI forms and summaries
  • show values like 3.5 instead of 3.50000

Example scenarios

• A shopping cart displays 12.5 instead of 12.50000
• A grade calculator shows 91.235 rounded to 91.24
• A sensor reading displays 0.9123 rather than 0.91230

In all of these, users care about both correctness and readability.

In real projects, developers usually separate internal numeric calculations from final display formatting.

Common patterns

1. Compute first, format last

Do calculations using BigDecimal or numeric types, then format only when showing output.

BigDecimal total = new BigDecimal("12.3456");
String display = total.setScale(2, RoundingMode.HALF_UP).toPlainString();

2. Centralize formatting logic

Instead of repeating formatting code everywhere, create a utility method.

public static String formatAmount(double value) {
    DecimalFormat df = new DecimalFormat("0.##");
    df.setRoundingMode(RoundingMode.HALF_UP);
    return df.format(value);
}

This avoids inconsistent output across the codebase.

3. Use BigDecimal for business rules

1. Using String.format when you do not want trailing zeros

Broken example:

System.out.println(String.format("%.5f", 0.912300));

Output:

0.91230

Why it happens:

• %.5f means exactly 5 digits after the decimal point

Use this instead when trailing zeros should be optional:

DecimalFormat df = new DecimalFormat("0.#####");
df.setRoundingMode(RoundingMode.HALF_UP);

2. Forgetting to set the rounding mode

Broken example:

DecimalFormat df = new DecimalFormat("0.#####");
System.out.println(df.format(0.912385));

This may not use the rounding behavior you expect.

Fix:

DecimalFormat vs

Quick solution

DecimalFormat df = new DecimalFormat("0.#####");
df.setRoundingMode(RoundingMode.HALF_UP);
String result = df.format(0.912385); // 0.91239

Pattern rules

• 0 = required digit
• # = optional digit
• 0.##### = up to 5 decimal places, no forced trailing zeros
• 0.00000 = exactly 5 decimal places

Rounding mode

RoundingMode.HALF_UP

• 5 rounds upward
• common “schoolbook” rounding

Reusable method

public static String formatRounded(double value, int decimalPlaces) {
    StringBuilder    ();
     (decimalPlaces > ) {
        pattern.append();
         (   ; i < decimalPlaces; i++) {
            pattern.append();
        }
    }

        (pattern.toString());
    df.setRoundingMode(RoundingMode.HALF_UP);
     df.format(value);
}

How do I round to 2 or 5 decimal places in Java?

Use DecimalFormat for display formatting or BigDecimal.setScale() for precise decimal rounding.

How do I remove trailing zeros after rounding in Java?

Use DecimalFormat with # placeholders, such as 0.#####, or use BigDecimal.stripTrailingZeros().

What is the difference between HALF_UP and HALF_EVEN?

HALF_UP rounds .5 upward. HALF_EVEN rounds toward the nearest even digit in tie cases. HALF_EVEN is often used to reduce rounding bias over many calculations.

Why does String.format keep extra zeros?

Because formats like %.5f mean exactly 5 digits after the decimal point.

Should I use double or BigDecimal for rounding?

Use for general-purpose numeric work and formatting. Use when exact decimal precision matters, such as money or business calculations.

• BigDecimal - Used for exact decimal arithmetic and controlled rounding.
• RoundingMode - Defines how Java should round values such as HALF_UP or HALF_EVEN.
• DecimalFormat - Formats numbers as strings using customizable patterns.
• String.format - Useful for fixed-width or fixed-decimal output.
• Floating-point precision - Explains why double can behave unexpectedly with decimal values.
• Number formatting patterns - Helps you understand 0, #, grouping, and decimal rules.
• stripTrailingZeros - Useful when formatting BigDecimal results without extra zeros.