How to format numbers in Java using DecimalFormat

Use DecimalFormat to accurately control digital formats. 1. Use pattern strings such as "#,###.##" for basic formatting, where # represents an optional number, 0 represents a must-display number, is a thousand separator, and is a decimal point; 2. Common patterns include "0.00" to retain two decimal places, "0,000.000" to complement zero alignment, etc.; 3. Avoid scientific notation methods by setting setScientificNotation(false) or using a pattern with sufficient digits; 4. You can set rounding modes through setRoundingMode(), such as HALF_UP, DOWN, etc.; 5. You can simulate currency formats such as "$#,##0.00", but it is recommended to use NumberFormat.getCurrencyInstance() to process the actual currency; 6. Use parse() method to parse the string into a number, and you need to capture ParseException; 7. Note that DecimalFormat is not thread-safe and is affected by Locale. You should choose the appropriate formatting method and handle exceptions according to your needs, so as to achieve flexible and reliable digital display.

Formatting numbers in Java using DecimalFormat is a common way to control how numeric values ​​are displayed, especially for decimal places, currency, percentages, and custom patterns. It's part of the java.text package and give you fine-grained control over number presentation.

Here's how to use DecimalFormat effectively:

Basic Usage of DecimalFormat

DecimalFormat allows you to format numbers using a pattern string made up of special symbols.

 import java.text.DecimalFormat;

public class NumberFormatting {
    public static void main(String[] args) {
        double number = 1234.567;

        DecimalFormat df = new DecimalFormat("#,###.##");
        String formatted = df.format(number);
        System.out.println(formatted); // Output: 1,234.57
    }
}

• # means an optional digit (no zero show if missing).
• 0 means a required digit (shows zero if missing).
• , is the grouping separator (eg, thousands).
• . is the decimal separator.

Common Format Patterns

Here are some useful patterns and their outputs for the value 1234.567 :

• "0" → 1235 (rounds and ensures at least one digit)
• "0.00" → 1234.57 (two decimal places, rounded)
• "#,###.##" → 1,234.57 (thousands separator, up to two decimals)
• "0,000.000" → 1,234.567 (pads with zeros to match format)
• "##0.########" → 1234.567 (trailing zeros not shown)

Example:

 DecimalFormat df = new DecimalFormat("0.00");
System.out.println(df.format(5.6)); // Output: 5.60

Handling Special Cases

1. Avoid Scientific Notation

Large numbers might default to scientific notation. To prevent this:

 DecimalFormat df = new DecimalFormat("0");
df.setScientificNotation(false);
System.out.println(df.format(123456789)); // Output: 123456789

Alternatively, use enough # or 0 in the pattern to avoid overflow.

2. Controlling Rounding Mode

By default, DecimalFormat uses half-up rounding. You can change it:

 import java.math.RoundingMode;

DecimalFormat df = new DecimalFormat("#.##");
df.setRoundingMode(RoundingMode.DOWN);
System.out.println(df.format(1.555)); // Output: 1.55

Other common modes: UP , CEILING , FLOOR , HALF_UP , HALF_DOWN .

3. Format Currency (Without Currency Symbol)

While NumberFormat.getCurrencyInstance() is better for real currency, you can simulate it:

 DecimalFormat df = new DecimalFormat("$#,##0.00");
System.out.println(df.format(1234.5)); // Output: $1,234.50

But for real applications, prefer NumberFormat.getCurrencyInstance() with locale.

Parsing Strings Back to Numbers

DecimalFormat can also parse formatted strings back into numbers:

 DecimalFormat df = new DecimalFormat("#,###.##");
try {
    Number num = df.parse("1,234.57");
    System.out.println(num.doubleValue()); // Output: 1234.57
} catch (Exception e) {
    e.printStackTrace();
}

Be cautious with parsing — mismatched formats cause ParseException .

Important Notes

• DecimalFormat is not thread-safe. Don't share instances across threads without synchronization.
• Locale settings affect default formatting. For locale-aware formatting (eg, European decimal commas), consider NumberFormat with specific locales.
• Always handle ParseException when parsing strings.

Using DecimalFormat gives you precise control over number appearance, making it ideal for reports, UIs, or data exports where formatting matters. Just define a clear pattern and adjust rounding or parsing as needed.

Basically, pick the right pattern, tweak rounding if necessary, and remember to handle edge cases.

The above is the detailed content of How to format numbers in Java using DecimalFormat. For more information, please follow other related articles on the PHP Chinese website!