public Class DecimalFormat

Getting a DecimalFormat

If the factory methods are not desired, use one of the constructors such as DecimalFormat(String pattern). See the Pattern section for more information on the pattern parameter.

Using DecimalFormat

NumberFormat nFmt = NumberFormat.getCurrencyInstance(Locale.US);
if (nFmt instanceof DecimalFormat dFmt) {
    // pattern match to DecimalFormat to use setPositiveSuffix(String)
    dFmt.setPositiveSuffix(" dollars");
    dFmt.format(100000); // returns "$100,000.00 dollars"
    dFmt.parse("$100,000.00 dollars"); // returns 100000
}

Formatting and Parsing

Rounding

Digits

When parsing, these digits as well as all Unicode decimal digits, as defined by Character.digit, are recognized.

Integer and Fraction Digit Limits

Special Values

• Not a Number (NaN) is formatted as a string, which is typically given as "NaN". This string is determined by DecimalFormatSymbols#getNaN(). This is the only value for which the prefixes and suffixes are not attached.

• Infinity is formatted as a string, which is typically given as "∞" (U+221E), with the positive or negative prefixes and suffixes attached. This string is determined by DecimalFormatSymbols#getInfinity().

• Negative zero ("-0") parses to

  • BigDecimal(0) if isParseBigDecimal() is true
  • Long(0) if isParseBigDecimal() is false and isParseIntegerOnly() is true
  • Double(-0.0) if both isParseBigDecimal() and isParseIntegerOnly() are false

Synchronization

Decimal formats are generally not synchronized. It is recommended to create separate format instances for each thread. If multiple threads access a format concurrently, it must be synchronized externally.

DecimalFormat Pattern

DecimalFormat patterns have the following syntax:

Pattern:
        PositivePattern
        PositivePattern ; NegativePattern
PositivePattern:
        Prefixopt Number Suffixopt
NegativePattern:
        Prefixopt Number Suffixopt
Prefix:
        Any characters except the special pattern characters
Suffix:
        Any characters except the special pattern characters
Number:
        Integer Exponentopt
        Integer . Fraction Exponentopt
Integer:
        MinimumInteger
        #
        # Integer
        # , Integer
MinimumInteger:
        0
        0 MinimumInteger
        0 , MinimumInteger
Fraction:
        MinimumFractionopt OptionalFractionopt
MinimumFraction:
        0 MinimumFractionopt
OptionalFraction:
        # OptionalFractionopt
Exponent:
        E MinimumExponent
MinimumExponent:
        0 MinimumExponentopt

Special Pattern Characters

The special characters in the table below are interpreted syntactically when used in the DecimalFormat pattern. They must be quoted, unless noted otherwise, if they are to appear in the prefix or suffix as literals.

The characters in the Symbol column are used in non-localized patterns. The corresponding characters in the Localized Symbol column are used in localized patterns, with the characters in Symbol losing their syntactical meaning. Two exceptions are the currency sign (U+00A4) and quote (U+0027), which are not localized.

Non-localized patterns should be used when calling applyPattern(String). Localized patterns should be used when calling applyLocalizedPattern(String).

Chart showing symbol, location, localized, and meaning.

Symbol	Localized Symbol	Location	Meaning
0	DecimalFormatSymbols#getZeroDigit()	Number	Digit
#	DecimalFormatSymbols#getDigit()	Number	Digit, zero shows as absent
.	DecimalFormatSymbols#getDecimalSeparator()	Number	Decimal separator or monetary decimal separator
- (U+002D)	DecimalFormatSymbols#getMinusSign()	Number	Minus sign
,	DecimalFormatSymbols#getGroupingSeparator()	Number	Grouping separator or monetary grouping separator
E	DecimalFormatSymbols#getExponentSeparator()	Number	Separates mantissa and exponent in scientific notation. This value is case sensistive. Need not be quoted in prefix or suffix.
;	DecimalFormatSymbols#getPatternSeparator()	Subpattern boundary	Separates positive and negative subpatterns
%	DecimalFormatSymbols#getPercent()	Prefix or suffix	Multiply by 100 and show as percentage
‰ (U+2030)	DecimalFormatSymbols#getPerMill()	Prefix or suffix	Multiply by 1000 and show as per mille value
¤ (U+00A4)	n/a (not localized)	Prefix or suffix	Currency sign, replaced by currency symbol. If doubled, replaced by international currency symbol. If present in a pattern, the monetary decimal/grouping separators are used instead of the decimal/grouping separators.
' (U+0027)	n/a (not localized)	Prefix or suffix	Used to quote special characters in a prefix or suffix, for example, "'#'#" formats 123 to "#123". To create a single quote itself, use two in a row: "# o''clock".

Maximum Digits Derivation

Negative Subpatterns

The prefixes, suffixes, and various symbols used for infinity, digits, grouping separators, decimal separators, etc. may be set to arbitrary values, and they will appear properly during formatting. However, care must be taken that the symbols and strings do not conflict, or parsing will be unreliable. For example, either the positive and negative prefixes or the suffixes must be distinct for DecimalFormat.parse() to be able to distinguish positive from negative values. (If they are identical, then DecimalFormat will behave as if no negative subpattern was specified.) Another example is that the decimal separator and grouping separator should be distinct characters, or parsing will be impossible.

Grouping Separator

The grouping separator is commonly used for thousands, but in some locales it separates ten-thousands. The grouping size is a constant number of digits between the grouping characters, such as 3 for 100,000,000 or 4 for 1,0000,0000. If you supply a pattern with multiple grouping characters, the interval between the last one and the end of the integer is the one that is used. For example, "#,##,###,####" == "######,####" == "##,####,####".

Scientific Notation

Numbers in scientific notation are expressed as the product of a mantissa and a power of ten, for example, 1234 can be expressed as 1.234 x 10^3. The mantissa is often in the range 1.0 ≤ x < 10.0, but it need not be. DecimalFormat can be instructed to format and parse scientific notation only via a pattern; there is currently no factory method that creates a scientific notation format. In a pattern, the exponent character immediately followed by one or more digit characters indicates scientific notation. Example: "0.###E0" formats the number 1234 as "1.234E3".

• The number of digit characters after the exponent character gives the minimum exponent digit count. There is no maximum. Negative exponents are formatted using the localized minus sign, not the prefix and suffix from the pattern. This allows patterns such as "0.###E0 m/s".
• The maximum integer digits is the sum of '0's and '#'s prior to the decimal point. The minimum integer digits is the sum of the '0's prior to the decimal point. The maximum fraction and minimum fraction digits follow the same rules, but apply to the digits after the decimal point but before the exponent. For example, the following pattern: "#00.0####E0" would have a minimum number of integer digits = 2("00") and a maximum number of integer digits = 3("#00"). It would have a minimum number of fraction digits = 1("0") and a maximum number of fraction digits= 5("0####").
• The minimum and maximum number of integer digits are interpreted together:
  • If the maximum number of integer digits is greater than their minimum number and greater than 1, it forces the exponent to be a multiple of the maximum number of integer digits, and the minimum number of integer digits to be interpreted as 1. The most common use of this is to generate engineering notation, in which the exponent is a multiple of three, e.g., "##0.#####E0". Using this pattern, the number 12345 formats to "12.345E3", and 123456 formats to "123.456E3".
  • Otherwise, the minimum number of integer digits is achieved by adjusting the exponent. Example: 0.00123 formatted with "00.###E0" yields "12.3E-4".
• For a given number, the amount of significant digits in the mantissa can be calculated as such

  Mantissa Digits:
          min(max(Minimum Pattern Digits, Original Number Digits), Maximum Pattern Digits)
  Minimum pattern Digits:
          Minimum Integer Digits + Minimum Fraction Digits
  Maximum pattern Digits:
          Maximum Integer Digits + Maximum Fraction Digits
  Original Number Digits:
          The amount of significant digits in the number to be formatted
  

  This means that generally, a mantissa will have up to the combined maximum integer and fraction digits, if the original number itself has enough significant digits. However, if there are more minimum pattern digits than significant digits in the original number, the mantissa will have significant digits that equals the combined minimum integer and fraction digits. The number of significant digits does not affect parsing.

  It should be noted, that the integer portion of the mantissa will give any excess digits to the fraction portion, whether it be for precision or for satisfying the total amount of combined minimum digits.

  This behavior can be observed in the following example,

   DecimalFormat df = new DecimalFormat("#000.000##E0"); df.format(12); // returns "12.0000E0" df.format(123456789) // returns "1.23456789E8"

  DecimalFormat df = new DecimalFormat("#000.000##E0");
  df.format(12); // returns "12.0000E0"
  df.format(123456789) // returns "1.23456789E8"
  

• Exponential patterns may not contain grouping separators.