public abstract Class NumberFormat

Getting a NumberFormat

• Use getInstance() or getNumberInstance() to get a decimal format. For example, "2,000.5".
• Use getIntegerInstance() to get an integer number format. For example, "2,000".
• Use getCurrencyInstance to get a currency number format. For example, "$2,000.50".
• Use getCompactNumberInstance to get a compact number format. For example, "2K".
• Use getPercentInstance to get a format for displaying percentages. For example, "200,050%".

Locale Extensions

• "nu" ( Numbering System) - Overrides the decimal digits used
• "rg" ( Region Override) - Overrides the country used
• "cf" ( Currency Format style) - Overrides the Currency Format style used
• "cu" ( Currency Type) - Overrides the Currency used

For both "nu" and "cu", if they are specified in addition to "rg", the respective values from the "nu" and "cu" extension supersede the implicit ones from the "rg" extension. Although Unicode extensions defines various keys and values, actual locale-sensitive service implementations in a Java Runtime Environment might not support any particular Unicode locale attributes or key/type pairs.

Below is an example of a "US" locale currency format with accounting style,

NumberFormat.getCurrencyInstance(Locale.forLanguageTag("en-US-u-cf-account"));

Using NumberFormat

NumberFormat currencyFormat = NumberFormat.getCurrencyInstance(Locale.US);
currencyFormat.format(100000); // returns "$100,000.00"
currencyFormat.parse("$100,000.00"); // returns 100000

Customizing NumberFormat

• setParseIntegerOnly(boolean); when true, will only return the integer portion of the number parsed from the String.
• setMinimumFractionDigits(int); Use to adjust the expected digits when formatting. Use any of the other minimum/maximum or fraction/integer setter methods in the same manner. These methods have no impact on parsing behavior.
• setGroupingUsed(boolean); when true, formatted numbers will be displayed with grouping separators. Additionally, when false, parsing will not expect grouping separators in the parsed String.
• setStrict(boolean); when true, parsing will be done strictly. The behavior of strict parsing should be referred to in the implementing NumberFormat subclass.

To provide more control over formatting or parsing behavior, type checking can be done to safely convert to an implementing subclass of NumberFormat; this provides additional methods defined by the subclass. For example,

NumberFormat nFmt = NumberFormat.getInstance(Locale.US);
if (nFmt instanceof DecimalFormat dFmt) {
    dFmt.setDecimalSeparatorAlwaysShown(true);
    dFmt.format(100); // returns "100."
}

You can also use forms of the parse and format methods with ParsePosition and FieldPosition to allow you to:

• Progressively parse through pieces of a string
• Align the decimal point and other areas

1. If you are using a monospaced font with spacing for alignment, you can pass the FieldPosition in your format call, with field = INTEGER_FIELD. On output, getEndIndex will be set to the offset between the last character of the integer and the decimal. Add (desiredSpaceCount - getEndIndex) spaces at the front of the string.
2. If you are using proportional fonts, instead of padding with spaces, measure the width of the string in pixels from the start to getEndIndex. Then move the pen by (desiredPixelWidth - widthToAlignmentPoint) before drawing the text. It also works where there is no decimal, but possibly additional characters at the end, e.g., with parentheses in negative numbers: "(12)" for -12.

Leniency

Lenient parsing should be used when attempting to parse a number out of a String that contains non-numerical or non-format related values. For example, using a Locale#US currency format to parse the number 1000 out of the String "$1,000.00 was paid". Lenient parsing also allows loose matching of characters in the source text. For example, an implementation of the NumberFormat class may allow matching "−" (U+2212 MINUS SIGN) to the "-" (U+002D HYPHEN-MINUS) pattern character when used as a negative prefix.

Strict parsing should be used when attempting to ensure a String adheres exactly to a locale's conventions, and can thus serve to validate input. For example, successfully parsing the number 1000.55 out of the String "1.000,55" confirms the String exactly adhered to the Locale#GERMANY numerical conventions.

Synchronization