DecimalFormat is a concrete subclass of
- * {@link NumberFormat} that formats decimal numbers.
- *
- * To obtain a {@link NumberFormat} for a specific locale (including the
- * default locale) call one of NumberFormat's factory methods such
- * as {@link NumberFormat#getInstance}. Do not call the DecimalFormat
- * constructors directly, unless you know what you are doing, since the
- * {@link NumberFormat} factory methods may return subclasses other than
- * DecimalFormat. If you need to customize the format object, do
- * something like this:
- *
- *
- * NumberFormat f = NumberFormat.getInstance(loc);
- * if (f instanceof DecimalFormat) {
- * ((DecimalFormat) f).setDecimalSeparatorAlwaysShown(true);
- * }Example Usage - * - *
- * // Print out a number using the localized number, currency,
- * // and percent format for each locale
- * Locale[] locales = NumberFormat.getAvailableLocales();
- * double myNumber = -1234.56;
- * NumberFormat format;
- * for (int j=0; j<3; ++j) {
- * System.out.println("FORMAT");
- * for (int i = 0; i < locales.length; ++i) {
- * if (locales[i].getCountry().length() == 0) {
- * // Skip language-only locales
- * continue;
- * }
- * System.out.print(locales[i].getDisplayName());
- * switch (j) {
- * case 0:
- * format = NumberFormat.getInstance(locales[i]); break;
- * case 1:
- * format = NumberFormat.getCurrencyInstance(locales[i]); break;
- * default:
- * format = NumberFormat.getPercentInstance(locales[i]); break;
- * }
- * try {
- * // Assume format is a DecimalFormat
- * System.out.print(": " + ((DecimalFormat) format).toPattern()
- * + " -> " + form.format(myNumber));
- * } catch (Exception e) {}
- * try {
- * System.out.println(" -> " + format.parse(form.format(myNumber)));
- * } catch (ParseException e) {}
- * }
- * }A DecimalFormat consists of a pattern and a set of
- * symbols. The pattern may be set directly using
- * {@link #applyPattern}, or indirectly using other API methods which
- * manipulate aspects of the pattern, such as the minimum number of integer
- * digits. The symbols are stored in a {@link DecimalFormatSymbols}
- * object. When using the {@link NumberFormat} factory methods, the
- * pattern and symbols are read from ICU's locale data.
- *
- *
Many characters in a pattern are taken literally; they are matched during - * parsing and output unchanged during formatting. Special characters, on the - * other hand, stand for other characters, strings, or classes of characters. - * For example, the '#' character is replaced by a localized digit. Often the - * replacement character is the same as the pattern character; in the U.S. locale, - * the ',' grouping character is replaced by ','. However, the replacement is - * still happening, and if the symbols are modified, the grouping character - * changes. Some special characters affect the behavior of the formatter by - * their presence; for example, if the percent character is seen, then the - * value is multiplied by 100 before being displayed. - * - *
To insert a special character in a pattern as a literal, that is, without - * any special meaning, the character must be quoted. There are some exceptions to - * this which are noted below. - * - *
The characters listed here are used in non-localized patterns. Localized - * patterns use the corresponding characters taken from this formatter's - * {@link DecimalFormatSymbols} object instead, and these characters lose - * their special status. Two exceptions are the currency sign and quote, which - * are not localized. - * - *
- *- * - *- *
- *- * Symbol - * Location - * Localized? - * Meaning - * - * 0- *Number - * Yes - * Digit - * - * 1-9- *Number - * Yes - * NEW - * '1' through '9' indicate rounding. - * - * @- *Number - * No - * NEW - * Significant digit - * - * #- *Number - * Yes - * Digit, zero shows as absent - * - * .- *Number - * Yes - * Decimal separator or monetary decimal separator - * - * -- *Number - * Yes - * Minus sign - * - * ,- *Number - * Yes - * Grouping separator - * - * E- *Number - * Yes - * Separates mantissa and exponent in scientific notation. - * Need not be quoted in prefix or suffix. - * - * +- *Exponent - * Yes - * NEW - * Prefix positive exponents with localized plus sign. - * Need not be quoted in prefix or suffix. - * - * ;- *Subpattern boundary - * Yes - * Separates positive and negative subpatterns - * - * %- *Prefix or suffix - * Yes - * Multiply by 100 and show as percentage - * - * \u2030- *Prefix or suffix - * Yes - * Multiply by 1000 and show as per mille - * - * ¤(\u00A4) - *Prefix or suffix - * No - * Currency sign, replaced by currency symbol. If - * doubled, replaced by international currency symbol. - * If present in a pattern, the monetary decimal separator - * is used instead of the decimal separator. - * - * '- *Prefix or suffix - * No - * 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". - *- * *- *Prefix or suffix boundary - * Yes - * NEW - * Pad escape, precedes pad character - *
A DecimalFormat pattern contains a postive and negative
- * subpattern, for example, "#,##0.00;(#,##0.00)". Each subpattern has a
- * prefix, a numeric part, and a suffix. If there is no explicit negative
- * subpattern, the negative subpattern is the localized minus sign prefixed to the
- * positive subpattern. That is, "0.00" alone is equivalent to "0.00;-0.00". If there
- * is an explicit negative subpattern, it serves only to specify the negative
- * prefix and suffix; the number of digits, minimal digits, and other
- * characteristics are ignored in the negative subpattern. That means that
- * "#,##0.0#;(#)" has precisely the same result as "#,##0.0#;(#,##0.0#)".
- *
- *
The prefixes, suffixes, and various symbols used for infinity, digits, - * thousands 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 {@link #parse} to be able - * to distinguish positive from negative values. Another example is that the - * decimal separator and thousands separator should be distinct characters, or - * parsing will be impossible. - * - *
The grouping separator is a character that separates clusters of - * integer digits to make large numbers more legible. It commonly used for - * thousands, but in some locales it separates ten-thousands. The grouping - * size is the number of digits between the grouping separators, such as 3 - * for "100,000,000" or 4 for "1 0000 0000". There are actually two different - * grouping sizes: One used for the least significant integer digits, the - * primary grouping size, and one used for all others, the - * secondary grouping size. In most locales these are the same, but - * sometimes they are different. For example, if the primary grouping interval - * is 3, and the secondary is 2, then this corresponds to the pattern - * "#,##,##0", and the number 123456789 is formatted as "12,34,56,789". If a - * pattern contains multiple grouping separators, the interval between the last - * one and the end of the integer defines the primary grouping size, and the - * interval between the last two defines the secondary grouping size. All others - * are ignored, so "#,##,###,####" == "###,###,####" == "##,#,###,####". - * - *
Illegal patterns, such as "#.#.#" or "#.###,###", will cause
- * DecimalFormat to throw an {@link IllegalArgumentException}
- * with a message that describes the problem.
- *
- *
- * pattern := subpattern (';' subpattern)?
- * subpattern := prefix? number exponent? suffix?
- * number := (integer ('.' fraction)?) | sigDigits
- * prefix := '\u0000'..'\uFFFD' - specialCharacters
- * suffix := '\u0000'..'\uFFFD' - specialCharacters
- * integer := '#'* '0'* '0'
- * fraction := '0'* '#'*
- * sigDigits := '#'* '@' '@'* '#'*
- * exponent := 'E' '+'? '0'* '0'
- * padSpec := '*' padChar
- * padChar := '\u0000'..'\uFFFD' - quote
- *
- * Notation:
- * X* 0 or more instances of X
- * X? 0 or 1 instances of X
- * X|Y either X or Y
- * C..D any character from C up to D, inclusive
- * S-T characters in S, except those in T
- *
- * The first subpattern is for positive numbers. The second (optional)
- * subpattern is for negative numbers.
- *
- * Not indicated in the BNF syntax above: - * - *
padSpec may appear before the prefix,
- * after the prefix, before the suffix, after the suffix, or not at all.
- *
- * DecimalFormat parses all Unicode characters that represent
- * decimal digits, as defined by {@link UCharacter#digit}. In addition,
- * DecimalFormat also recognizes as digits the ten consecutive
- * characters starting with the localized zero digit defined in the
- * {@link DecimalFormatSymbols} object. During formatting, the
- * {@link DecimalFormatSymbols}-based digits are output.
- *
- *
During parsing, grouping separators are ignored. - * - *
If {@link #parse(String, ParsePosition)} fails to parse
- * a string, it returns null and leaves the parse position
- * unchanged. The convenience method {@link #parse(String)}
- * indicates parse failure by throwing a {@link java.text.ParseException}.
- *
- *
Formatting is guided by several parameters, all of which can be - * specified either using a pattern or using the API. The following - * description applies to formats that do not use scientific - * notation or significant digits. - * - *
Special Values - * - *
NaN is represented as a single character, typically
- * \uFFFD. This character is determined by the
- * {@link DecimalFormatSymbols} object. This is the only value for which
- * the prefixes and suffixes are not used.
- *
- *
Infinity is represented as a single character, typically
- * \u221E, with the positive or negative prefixes and suffixes
- * applied. The infinity character is determined by the
- * {@link DecimalFormatSymbols} object.
- *
- * 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 103. The
- * mantissa is typically in the half-open interval [1.0, 10.0) or sometimes [0.0, 1.0),
- * but it need not be. DecimalFormat supports arbitrary mantissas.
- * DecimalFormat can be instructed to use scientific
- * notation through the API or through the pattern. 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".
- *
- *
DecimalFormat has two ways of controlling how many
- * digits are shows: (a) significant digits counts, or (b) integer and
- * fraction digit counts. Integer and fraction digit counts are
- * described above. When a formatter is using significant digits
- * counts, the number of integer and fraction digits is not specified
- * directly, and the formatter settings for these counts are ignored.
- * Instead, the formatter uses however many integer and fraction
- * digits are required to display the specified number of significant
- * digits. Examples:
- *
- * - *- * - *- *
- *- * Pattern - * Minimum significant digits - * Maximum significant digits - * Number - * Output of format() - * - * @@@- *3 - * 3 - * 12345 - * 12300- *- * @@@- *3 - * 3 - * 0.12345 - * 0.123- *- * @@##- *2 - * 4 - * 3.14159 - * 3.142- *- * @@##- *2 - * 4 - * 1.23004 - * 1.23- *
'@' and '#'
- * characters. The minimum number of significant digits is the number
- * of '@' characters. The maximum number of significant
- * digits is the number of '@' characters plus the number
- * of '#' characters following on the right. For
- * example, the pattern "@@@" indicates exactly 3
- * significant digits. The pattern "@##" indicates from
- * 1 to 3 significant digits. Trailing zero digits to the right of
- * the decimal separator are suppressed after the minimum number of
- * significant digits have been shown. For example, the pattern
- * "@##" formats the number 0.1203 as
- * "0.12".
- *
- * '0' pattern character.
- * Patterns such as "@00" or "@.###" are
- * disallowed.
- *
- * '#' characters may be prepended to
- * the left of the leftmost '@' character. These have no
- * effect on the minimum and maximum significant digits counts, but
- * may be used to position grouping separators. For example,
- * "#,#@#" indicates a minimum of one significant digits,
- * a maximum of two significant digits, and a grouping size of three.
- *
- * '@' pattern character. Alternatively,
- * call {@link #setSignificantDigitsUsed setSignificantDigitsUsed(true)}.
- *
- * '@' pattern
- * character. Alternatively, call {@link #setSignificantDigitsUsed
- * setSignificantDigitsUsed(false)}.
- *
- * getMinimumSignificantDigits() - 1, and a maximum fraction digit
- * count of getMaximumSignificantDigits() - 1. For example, the
- * pattern "@@###E0" is equivalent to "0.0###E0".
- *
- * DecimalFormat supports padding the result of
- * {@link #format} to a specific width. Padding may be specified either
- * through the API or through the pattern syntax. In a pattern the pad escape
- * character, followed by a single pad character, causes padding to be parsed
- * and formatted. The pad escape character is '*' in unlocalized patterns, and
- * can be localized using {@link DecimalFormatSymbols#setPadEscape}. For
- * example, "$*x#,##0.00" formats 123 to "$xx123.00",
- * and 1234 to "$1,234.00".
- *
- *
"* #0 o''clock", the format width is 10.
- *
- * chars).
- *
- * char immediately
- * following the pad escape is the pad character. This may be any character,
- * including a special pattern character. That is, the pad escape
- * escapes the following character. If there is no character after
- * the pad escape, then the pattern is illegal.
- *
- * - * NEW - * Rounding - * - *
DecimalFormat supports rounding to a specific increment. For
- * example, 1230 rounded to the nearest 50 is 1250. 1.234 rounded to the
- * nearest 0.65 is 1.3. The rounding increment may be specified through the API
- * or in a pattern. To specify a rounding increment in a pattern, include the
- * increment in the pattern itself. "#,#50" specifies a rounding increment of
- * 50. "#,##0.05" specifies a rounding increment of 0.05.
- *
- *
DecimalFormat objects are not synchronized. Multiple
- * threads should not access one formatter concurrently.
- *
- * @see java.text.Format
- * @see NumberFormat
- * @author Mark Davis
- * @author Alan Liu
- * @stable ICU 2.0
- */
-public class DecimalFormat extends NumberFormat {
-
- private static final long serialVersionUID = 1L;
- /**
- * @internal
- * @param delegate the NumberFormat to which to delegate
- */
- public DecimalFormat(java.text.DecimalFormat delegate) {
- super(delegate);
- }
-
- /**
- * Create a DecimalFormat using the default pattern and symbols
- * for the default locale. This is a convenient way to obtain a
- * DecimalFormat when internationalization is not the main concern.
- *
- * To obtain standard formats for a given locale, use the factory methods - * on NumberFormat such as getNumberInstance. These factories will - * return the most appropriate sub-class of NumberFormat for a given - * locale. - * @see NumberFormat#getInstance - * @see NumberFormat#getNumberInstance - * @see NumberFormat#getCurrencyInstance - * @see NumberFormat#getPercentInstance - * @stable ICU 2.0 - */ - public DecimalFormat() { - this(new java.text.DecimalFormat()); - } - - /** - * Create a DecimalFormat from the given pattern and the symbols - * for the default locale. This is a convenient way to obtain a - * DecimalFormat when internationalization is not the main concern. - *
- * To obtain standard formats for a given locale, use the factory methods - * on NumberFormat such as getNumberInstance. These factories will - * return the most appropriate sub-class of NumberFormat for a given - * locale. - * @param pattern A non-localized pattern string. - * @exception IllegalArgumentException if the given pattern is invalid. - * @see NumberFormat#getInstance - * @see NumberFormat#getNumberInstance - * @see NumberFormat#getCurrencyInstance - * @see NumberFormat#getPercentInstance - * @stable ICU 2.0 - */ - public DecimalFormat(String pattern) { - this(new java.text.DecimalFormat(pattern)); - } - - - /** - * Create a DecimalFormat from the given pattern and symbols. - * Use this constructor when you need to completely customize the - * behavior of the format. - *
- * To obtain standard formats for a given - * locale, use the factory methods on NumberFormat such as - * getInstance or getCurrencyInstance. If you need only minor adjustments - * to a standard format, you can modify the format returned by - * a NumberFormat factory method. - * @param pattern a non-localized pattern string - * @param symbols the set of symbols to be used - * @exception IllegalArgumentException if the given pattern is invalid - * @see NumberFormat#getInstance - * @see NumberFormat#getNumberInstance - * @see NumberFormat#getCurrencyInstance - * @see NumberFormat#getPercentInstance - * @see DecimalFormatSymbols - * @stable ICU 2.0 - */ - public DecimalFormat(String pattern, DecimalFormatSymbols symbols) { - this(new java.text.DecimalFormat(pattern, symbols.dfs)); - } - - /** - * Returns a copy of the decimal format symbols used by this format. - * @return desired DecimalFormatSymbols - * @see DecimalFormatSymbols - * @stable ICU 2.0 - */ - public DecimalFormatSymbols getDecimalFormatSymbols() { - return new DecimalFormatSymbols(((java.text.DecimalFormat)numberFormat).getDecimalFormatSymbols()); - } - - /** - * Sets the decimal format symbols used by this format. The - * format uses a copy of the provided symbols. - * @param newSymbols desired DecimalFormatSymbols - * @see DecimalFormatSymbols - * @stable ICU 2.0 - */ - public void setDecimalFormatSymbols(DecimalFormatSymbols newSymbols) { - ((java.text.DecimalFormat)numberFormat).setDecimalFormatSymbols(newSymbols.dfs); - } - - - /** - * Get the positive prefix. - *
Examples: +123, $123, sFr123 - * @stable ICU 2.0 - */ - public String getPositivePrefix() { - return ((java.text.DecimalFormat)numberFormat).getPositivePrefix(); - } - - /** - * Set the positive prefix. - *
Examples: +123, $123, sFr123 - * @stable ICU 2.0 - */ - public void setPositivePrefix(String newValue) { - ((java.text.DecimalFormat)numberFormat).setPositivePrefix(newValue); - } - - /** - * Get the negative prefix. - *
Examples: -123, ($123) (with negative suffix), sFr-123 - * @stable ICU 2.0 - */ - public String getNegativePrefix () { - return ((java.text.DecimalFormat)numberFormat).getNegativePrefix(); - } - - /** - * Set the negative prefix. - *
Examples: -123, ($123) (with negative suffix), sFr-123 - * @stable ICU 2.0 - */ - public void setNegativePrefix (String newValue) { - ((java.text.DecimalFormat)numberFormat).setNegativePrefix(newValue); - } - - /** - * Get the positive suffix. - *
Example: 123% - * @stable ICU 2.0 - */ - public String getPositiveSuffix () { - return ((java.text.DecimalFormat)numberFormat).getPositiveSuffix(); - } - - /** - * Set the positive suffix. - *
Example: 123% - * @stable ICU 2.0 - */ - public void setPositiveSuffix (String newValue) { - ((java.text.DecimalFormat)numberFormat).setPositiveSuffix(newValue); - } - - /** - * Get the negative suffix. - *
Examples: -123%, ($123) (with positive suffixes) - * @stable ICU 2.0 - */ - public String getNegativeSuffix () { - return ((java.text.DecimalFormat)numberFormat).getNegativeSuffix(); - } - - /** - * Set the positive suffix. - *
Examples: 123% - * @stable ICU 2.0 - */ - public void setNegativeSuffix (String newValue) { - ((java.text.DecimalFormat)numberFormat).setNegativeSuffix(newValue); - } - - /** - * Get the multiplier for use in percent, permill, etc. - * For a percentage, set the suffixes to have "%" and the multiplier to be 100. - * (For Arabic, use arabic percent symbol). - * For a permill, set the suffixes to have "\u2031" and the multiplier to be 1000. - *
Examples: with 100, 1.23 -> "123", and "123" -> 1.23 - * @stable ICU 2.0 - */ - public int getMultiplier () { - return ((java.text.DecimalFormat)numberFormat).getMultiplier(); - } - - /** - * Set the multiplier for use in percent, permill, etc. - * For a percentage, set the suffixes to have "%" and the multiplier to be 100. - * (For Arabic, use arabic percent symbol). - * For a permill, set the suffixes to have "\u2031" and the multiplier to be 1000. - *
Examples: with 100, 1.23 -> "123", and "123" -> 1.23 - * @stable ICU 2.0 - */ - public void setMultiplier (int newValue) { - ((java.text.DecimalFormat)numberFormat).setMultiplier(newValue); - } - - /** - * Return the grouping size. Grouping size is the number of digits between - * grouping separators in the integer portion of a number. For example, - * in the number "123,456.78", the grouping size is 3. - * @see #setGroupingSize - * @see NumberFormat#isGroupingUsed - * @see DecimalFormatSymbols#getGroupingSeparator - * @stable ICU 2.0 - */ - public int getGroupingSize () { - return ((java.text.DecimalFormat)numberFormat).getGroupingSize(); - } - - /** - * Set the grouping size. Grouping size is the number of digits between - * grouping separators in the integer portion of a number. For example, - * in the number "123,456.78", the grouping size is 3. - * @see #getGroupingSize - * @see NumberFormat#setGroupingUsed - * @see DecimalFormatSymbols#setGroupingSeparator - * @stable ICU 2.0 - */ - public void setGroupingSize (int newValue) { - ((java.text.DecimalFormat)numberFormat).setGroupingSize(newValue); - } - - /** - * Allows you to get the behavior of the decimal separator with integers. - * (The decimal separator will always appear with decimals.) - *
Example: Decimal ON: 12345 -> 12345.; OFF: 12345 -> 12345 - * @stable ICU 2.0 - */ - public boolean isDecimalSeparatorAlwaysShown() { - return ((java.text.DecimalFormat)numberFormat).isDecimalSeparatorAlwaysShown(); - } - - /** - * Allows you to set the behavior of the decimal separator with integers. - * (The decimal separator will always appear with decimals.) - * - *
This only affects formatting, and only where - * there might be no digits after the decimal point, e.g., - * if true, 3456.00 -> "3,456." - * if false, 3456.00 -> "3456" - * This is independent of parsing. If you want parsing to stop at the decimal - * point, use setParseIntegerOnly. - * - *
Example: Decimal ON: 12345 -> 12345.; OFF: 12345 -> 12345 - * @stable ICU 2.0 - */ - public void setDecimalSeparatorAlwaysShown(boolean newValue) { - ((java.text.DecimalFormat)numberFormat).setDecimalSeparatorAlwaysShown(newValue); - } - - /** - * Standard override; no change in semantics. - * @stable ICU 2.0 - */ - public Object clone() { - return new DecimalFormatSymbols((java.text.DecimalFormatSymbols)numberFormat.clone()); - } - - /** - * Synthesizes a pattern string that represents the current state - * of this Format object. - * @see #applyPattern - * @stable ICU 2.0 - */ - public String toPattern() { - return ((java.text.DecimalFormat)numberFormat).toPattern(); - } - - /** - * Synthesizes a localized pattern string that represents the current - * state of this Format object. - * @see #applyPattern - * @stable ICU 2.0 - */ - public String toLocalizedPattern() { - return ((java.text.DecimalFormat)numberFormat).toLocalizedPattern(); - } - - - /** - * Apply the given pattern to this Format object. A pattern is a - * short-hand specification for the various formatting properties. - * These properties can also be changed individually through the - * various setter methods. - *
- * There is no limit to integer digits are set - * by this routine, since that is the typical end-user desire; - * use setMaximumInteger if you want to set a real value. - * For negative numbers, use a second pattern, separated by a semicolon - *
Example "#,#00.0#" -> 1,234.56 - *
This means a minimum of 2 integer digits, 1 fraction digit, and - * a maximum of 2 fraction digits. - *
Example: "#,#00.0#;(#,#00.0#)" for negatives in parentheses. - *
In negative patterns, the minimum and maximum counts are ignored; - * these are presumed to be set in the positive pattern. - * @stable ICU 2.0 - */ - public void applyPattern(String pattern) { - ((java.text.DecimalFormat)numberFormat).applyPattern(pattern); - } - - /** - * Apply the given pattern to this Format object. The pattern - * is assumed to be in a localized notation. A pattern is a - * short-hand specification for the various formatting properties. - * These properties can also be changed individually through the - * various setter methods. - *
- * There is no limit to integer digits are set - * by this routine, since that is the typical end-user desire; - * use setMaximumInteger if you want to set a real value. - * For negative numbers, use a second pattern, separated by a semicolon - *
Example "#,#00.0#" -> 1,234.56 - *
This means a minimum of 2 integer digits, 1 fraction digit, and - * a maximum of 2 fraction digits. - *
Example: "#,#00.0#;(#,#00.0#)" for negatives in parentheses. - *
In negative patterns, the minimum and maximum counts are ignored;
- * these are presumed to be set in the positive pattern.
- * @stable ICU 2.0
- */
- public void applyLocalizedPattern(String pattern) {
- ((java.text.DecimalFormat)numberFormat).applyLocalizedPattern(pattern);
- }
-}
+/*
+ *******************************************************************************
+ * Copyright (C) 1996-2006, International Business Machines Corporation and *
+ * others. All Rights Reserved. *
+ *******************************************************************************
+ */
+
+package com.ibm.icu.text;
+
+/**
+ * DecimalFormat is a concrete subclass of
+ * {@link NumberFormat} that formats decimal numbers.
+ *
+ *
To obtain a {@link NumberFormat} for a specific locale (including the
+ * default locale) call one of NumberFormat's factory methods such
+ * as {@link NumberFormat#getInstance}. Do not call the DecimalFormat
+ * constructors directly, unless you know what you are doing, since the
+ * {@link NumberFormat} factory methods may return subclasses other than
+ * DecimalFormat. If you need to customize the format object, do
+ * something like this:
+ *
+ *
+ * NumberFormat f = NumberFormat.getInstance(loc);
+ * if (f instanceof DecimalFormat) {
+ * ((DecimalFormat) f).setDecimalSeparatorAlwaysShown(true);
+ * }Example Usage + * + *
+ * // Print out a number using the localized number, currency,
+ * // and percent format for each locale
+ * Locale[] locales = NumberFormat.getAvailableLocales();
+ * double myNumber = -1234.56;
+ * NumberFormat format;
+ * for (int j=0; j<3; ++j) {
+ * System.out.println("FORMAT");
+ * for (int i = 0; i < locales.length; ++i) {
+ * if (locales[i].getCountry().length() == 0) {
+ * // Skip language-only locales
+ * continue;
+ * }
+ * System.out.print(locales[i].getDisplayName());
+ * switch (j) {
+ * case 0:
+ * format = NumberFormat.getInstance(locales[i]); break;
+ * case 1:
+ * format = NumberFormat.getCurrencyInstance(locales[i]); break;
+ * default:
+ * format = NumberFormat.getPercentInstance(locales[i]); break;
+ * }
+ * try {
+ * // Assume format is a DecimalFormat
+ * System.out.print(": " + ((DecimalFormat) format).toPattern()
+ * + " -> " + form.format(myNumber));
+ * } catch (Exception e) {}
+ * try {
+ * System.out.println(" -> " + format.parse(form.format(myNumber)));
+ * } catch (ParseException e) {}
+ * }
+ * }A DecimalFormat consists of a pattern and a set of
+ * symbols. The pattern may be set directly using
+ * {@link #applyPattern}, or indirectly using other API methods which
+ * manipulate aspects of the pattern, such as the minimum number of integer
+ * digits. The symbols are stored in a {@link DecimalFormatSymbols}
+ * object. When using the {@link NumberFormat} factory methods, the
+ * pattern and symbols are read from ICU's locale data.
+ *
+ *
Many characters in a pattern are taken literally; they are matched during + * parsing and output unchanged during formatting. Special characters, on the + * other hand, stand for other characters, strings, or classes of characters. + * For example, the '#' character is replaced by a localized digit. Often the + * replacement character is the same as the pattern character; in the U.S. locale, + * the ',' grouping character is replaced by ','. However, the replacement is + * still happening, and if the symbols are modified, the grouping character + * changes. Some special characters affect the behavior of the formatter by + * their presence; for example, if the percent character is seen, then the + * value is multiplied by 100 before being displayed. + * + *
To insert a special character in a pattern as a literal, that is, without + * any special meaning, the character must be quoted. There are some exceptions to + * this which are noted below. + * + *
The characters listed here are used in non-localized patterns. Localized + * patterns use the corresponding characters taken from this formatter's + * {@link DecimalFormatSymbols} object instead, and these characters lose + * their special status. Two exceptions are the currency sign and quote, which + * are not localized. + * + *
+ *+ * + *+ *
+ *+ * Symbol + * Location + * Localized? + * Meaning + * + * 0+ *Number + * Yes + * Digit + * + * 1-9+ *Number + * Yes + * NEW + * '1' through '9' indicate rounding. + * + * @+ *Number + * No + * NEW + * Significant digit + * + * #+ *Number + * Yes + * Digit, zero shows as absent + * + * .+ *Number + * Yes + * Decimal separator or monetary decimal separator + * + * -+ *Number + * Yes + * Minus sign + * + * ,+ *Number + * Yes + * Grouping separator + * + * E+ *Number + * Yes + * Separates mantissa and exponent in scientific notation. + * Need not be quoted in prefix or suffix. + * + * ++ *Exponent + * Yes + * NEW + * Prefix positive exponents with localized plus sign. + * Need not be quoted in prefix or suffix. + * + * ;+ *Subpattern boundary + * Yes + * Separates positive and negative subpatterns + * + * %+ *Prefix or suffix + * Yes + * Multiply by 100 and show as percentage + * + * \u2030+ *Prefix or suffix + * Yes + * Multiply by 1000 and show as per mille + * + * ¤(\u00A4) + *Prefix or suffix + * No + * Currency sign, replaced by currency symbol. If + * doubled, replaced by international currency symbol. + * If present in a pattern, the monetary decimal separator + * is used instead of the decimal separator. + * + * '+ *Prefix or suffix + * No + * 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". + *+ * *+ *Prefix or suffix boundary + * Yes + * NEW + * Pad escape, precedes pad character + *
A DecimalFormat pattern contains a postive and negative
+ * subpattern, for example, "#,##0.00;(#,##0.00)". Each subpattern has a
+ * prefix, a numeric part, and a suffix. If there is no explicit negative
+ * subpattern, the negative subpattern is the localized minus sign prefixed to the
+ * positive subpattern. That is, "0.00" alone is equivalent to "0.00;-0.00". If there
+ * is an explicit negative subpattern, it serves only to specify the negative
+ * prefix and suffix; the number of digits, minimal digits, and other
+ * characteristics are ignored in the negative subpattern. That means that
+ * "#,##0.0#;(#)" has precisely the same result as "#,##0.0#;(#,##0.0#)".
+ *
+ *
The prefixes, suffixes, and various symbols used for infinity, digits, + * thousands 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 {@link #parse} to be able + * to distinguish positive from negative values. Another example is that the + * decimal separator and thousands separator should be distinct characters, or + * parsing will be impossible. + * + *
The grouping separator is a character that separates clusters of + * integer digits to make large numbers more legible. It commonly used for + * thousands, but in some locales it separates ten-thousands. The grouping + * size is the number of digits between the grouping separators, such as 3 + * for "100,000,000" or 4 for "1 0000 0000". There are actually two different + * grouping sizes: One used for the least significant integer digits, the + * primary grouping size, and one used for all others, the + * secondary grouping size. In most locales these are the same, but + * sometimes they are different. For example, if the primary grouping interval + * is 3, and the secondary is 2, then this corresponds to the pattern + * "#,##,##0", and the number 123456789 is formatted as "12,34,56,789". If a + * pattern contains multiple grouping separators, the interval between the last + * one and the end of the integer defines the primary grouping size, and the + * interval between the last two defines the secondary grouping size. All others + * are ignored, so "#,##,###,####" == "###,###,####" == "##,#,###,####". + * + *
Illegal patterns, such as "#.#.#" or "#.###,###", will cause
+ * DecimalFormat to throw an {@link IllegalArgumentException}
+ * with a message that describes the problem.
+ *
+ *
+ * pattern := subpattern (';' subpattern)?
+ * subpattern := prefix? number exponent? suffix?
+ * number := (integer ('.' fraction)?) | sigDigits
+ * prefix := '\u0000'..'\uFFFD' - specialCharacters
+ * suffix := '\u0000'..'\uFFFD' - specialCharacters
+ * integer := '#'* '0'* '0'
+ * fraction := '0'* '#'*
+ * sigDigits := '#'* '@' '@'* '#'*
+ * exponent := 'E' '+'? '0'* '0'
+ * padSpec := '*' padChar
+ * padChar := '\u0000'..'\uFFFD' - quote
+ *
+ * Notation:
+ * X* 0 or more instances of X
+ * X? 0 or 1 instances of X
+ * X|Y either X or Y
+ * C..D any character from C up to D, inclusive
+ * S-T characters in S, except those in T
+ *
+ * The first subpattern is for positive numbers. The second (optional)
+ * subpattern is for negative numbers.
+ *
+ * Not indicated in the BNF syntax above: + * + *
padSpec may appear before the prefix,
+ * after the prefix, before the suffix, after the suffix, or not at all.
+ *
+ * DecimalFormat parses all Unicode characters that represent
+ * decimal digits, as defined by {@link UCharacter#digit}. In addition,
+ * DecimalFormat also recognizes as digits the ten consecutive
+ * characters starting with the localized zero digit defined in the
+ * {@link DecimalFormatSymbols} object. During formatting, the
+ * {@link DecimalFormatSymbols}-based digits are output.
+ *
+ *
During parsing, grouping separators are ignored. + * + *
If {@link #parse(String, ParsePosition)} fails to parse
+ * a string, it returns null and leaves the parse position
+ * unchanged. The convenience method {@link #parse(String)}
+ * indicates parse failure by throwing a {@link java.text.ParseException}.
+ *
+ *
Formatting is guided by several parameters, all of which can be + * specified either using a pattern or using the API. The following + * description applies to formats that do not use scientific + * notation or significant digits. + * + *
Special Values + * + *
NaN is represented as a single character, typically
+ * \uFFFD. This character is determined by the
+ * {@link DecimalFormatSymbols} object. This is the only value for which
+ * the prefixes and suffixes are not used.
+ *
+ *
Infinity is represented as a single character, typically
+ * \u221E, with the positive or negative prefixes and suffixes
+ * applied. The infinity character is determined by the
+ * {@link DecimalFormatSymbols} object.
+ *
+ * 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 103. The
+ * mantissa is typically in the half-open interval [1.0, 10.0) or sometimes [0.0, 1.0),
+ * but it need not be. DecimalFormat supports arbitrary mantissas.
+ * DecimalFormat can be instructed to use scientific
+ * notation through the API or through the pattern. 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".
+ *
+ *
DecimalFormat has two ways of controlling how many
+ * digits are shows: (a) significant digits counts, or (b) integer and
+ * fraction digit counts. Integer and fraction digit counts are
+ * described above. When a formatter is using significant digits
+ * counts, the number of integer and fraction digits is not specified
+ * directly, and the formatter settings for these counts are ignored.
+ * Instead, the formatter uses however many integer and fraction
+ * digits are required to display the specified number of significant
+ * digits. Examples:
+ *
+ * + *+ * + *+ *
+ *+ * Pattern + * Minimum significant digits + * Maximum significant digits + * Number + * Output of format() + * + * @@@+ *3 + * 3 + * 12345 + * 12300+ *+ * @@@+ *3 + * 3 + * 0.12345 + * 0.123+ *+ * @@##+ *2 + * 4 + * 3.14159 + * 3.142+ *+ * @@##+ *2 + * 4 + * 1.23004 + * 1.23+ *
'@' and '#'
+ * characters. The minimum number of significant digits is the number
+ * of '@' characters. The maximum number of significant
+ * digits is the number of '@' characters plus the number
+ * of '#' characters following on the right. For
+ * example, the pattern "@@@" indicates exactly 3
+ * significant digits. The pattern "@##" indicates from
+ * 1 to 3 significant digits. Trailing zero digits to the right of
+ * the decimal separator are suppressed after the minimum number of
+ * significant digits have been shown. For example, the pattern
+ * "@##" formats the number 0.1203 as
+ * "0.12".
+ *
+ * '0' pattern character.
+ * Patterns such as "@00" or "@.###" are
+ * disallowed.
+ *
+ * '#' characters may be prepended to
+ * the left of the leftmost '@' character. These have no
+ * effect on the minimum and maximum significant digits counts, but
+ * may be used to position grouping separators. For example,
+ * "#,#@#" indicates a minimum of one significant digits,
+ * a maximum of two significant digits, and a grouping size of three.
+ *
+ * '@' pattern character. Alternatively,
+ * call {@link #setSignificantDigitsUsed setSignificantDigitsUsed(true)}.
+ *
+ * '@' pattern
+ * character. Alternatively, call {@link #setSignificantDigitsUsed
+ * setSignificantDigitsUsed(false)}.
+ *
+ * getMinimumSignificantDigits() - 1, and a maximum fraction digit
+ * count of getMaximumSignificantDigits() - 1. For example, the
+ * pattern "@@###E0" is equivalent to "0.0###E0".
+ *
+ * DecimalFormat supports padding the result of
+ * {@link #format} to a specific width. Padding may be specified either
+ * through the API or through the pattern syntax. In a pattern the pad escape
+ * character, followed by a single pad character, causes padding to be parsed
+ * and formatted. The pad escape character is '*' in unlocalized patterns, and
+ * can be localized using {@link DecimalFormatSymbols#setPadEscape}. For
+ * example, "$*x#,##0.00" formats 123 to "$xx123.00",
+ * and 1234 to "$1,234.00".
+ *
+ *
"* #0 o''clock", the format width is 10.
+ *
+ * chars).
+ *
+ * char immediately
+ * following the pad escape is the pad character. This may be any character,
+ * including a special pattern character. That is, the pad escape
+ * escapes the following character. If there is no character after
+ * the pad escape, then the pattern is illegal.
+ *
+ * + * NEW + * Rounding + * + *
DecimalFormat supports rounding to a specific increment. For
+ * example, 1230 rounded to the nearest 50 is 1250. 1.234 rounded to the
+ * nearest 0.65 is 1.3. The rounding increment may be specified through the API
+ * or in a pattern. To specify a rounding increment in a pattern, include the
+ * increment in the pattern itself. "#,#50" specifies a rounding increment of
+ * 50. "#,##0.05" specifies a rounding increment of 0.05.
+ *
+ *
DecimalFormat objects are not synchronized. Multiple
+ * threads should not access one formatter concurrently.
+ *
+ * @see java.text.Format
+ * @see NumberFormat
+ * @author Mark Davis
+ * @author Alan Liu
+ * @stable ICU 2.0
+ */
+public class DecimalFormat extends NumberFormat {
+
+ private static final long serialVersionUID = 1L;
+ /**
+ * @internal
+ * @param delegate the NumberFormat to which to delegate
+ */
+ public DecimalFormat(java.text.DecimalFormat delegate) {
+ super(delegate);
+ }
+
+ /**
+ * Create a DecimalFormat using the default pattern and symbols
+ * for the default locale. This is a convenient way to obtain a
+ * DecimalFormat when internationalization is not the main concern.
+ *
+ * To obtain standard formats for a given locale, use the factory methods + * on NumberFormat such as getNumberInstance. These factories will + * return the most appropriate sub-class of NumberFormat for a given + * locale. + * @see NumberFormat#getInstance + * @see NumberFormat#getNumberInstance + * @see NumberFormat#getCurrencyInstance + * @see NumberFormat#getPercentInstance + * @stable ICU 2.0 + */ + public DecimalFormat() { + this(new java.text.DecimalFormat()); + } + + /** + * Create a DecimalFormat from the given pattern and the symbols + * for the default locale. This is a convenient way to obtain a + * DecimalFormat when internationalization is not the main concern. + *
+ * To obtain standard formats for a given locale, use the factory methods + * on NumberFormat such as getNumberInstance. These factories will + * return the most appropriate sub-class of NumberFormat for a given + * locale. + * @param pattern A non-localized pattern string. + * @exception IllegalArgumentException if the given pattern is invalid. + * @see NumberFormat#getInstance + * @see NumberFormat#getNumberInstance + * @see NumberFormat#getCurrencyInstance + * @see NumberFormat#getPercentInstance + * @stable ICU 2.0 + */ + public DecimalFormat(String pattern) { + this(new java.text.DecimalFormat(pattern)); + } + + + /** + * Create a DecimalFormat from the given pattern and symbols. + * Use this constructor when you need to completely customize the + * behavior of the format. + *
+ * To obtain standard formats for a given + * locale, use the factory methods on NumberFormat such as + * getInstance or getCurrencyInstance. If you need only minor adjustments + * to a standard format, you can modify the format returned by + * a NumberFormat factory method. + * @param pattern a non-localized pattern string + * @param symbols the set of symbols to be used + * @exception IllegalArgumentException if the given pattern is invalid + * @see NumberFormat#getInstance + * @see NumberFormat#getNumberInstance + * @see NumberFormat#getCurrencyInstance + * @see NumberFormat#getPercentInstance + * @see DecimalFormatSymbols + * @stable ICU 2.0 + */ + public DecimalFormat(String pattern, DecimalFormatSymbols symbols) { + this(new java.text.DecimalFormat(pattern, symbols.dfs)); + } + + /** + * Returns a copy of the decimal format symbols used by this format. + * @return desired DecimalFormatSymbols + * @see DecimalFormatSymbols + * @stable ICU 2.0 + */ + public DecimalFormatSymbols getDecimalFormatSymbols() { + return new DecimalFormatSymbols(((java.text.DecimalFormat)numberFormat).getDecimalFormatSymbols()); + } + + /** + * Sets the decimal format symbols used by this format. The + * format uses a copy of the provided symbols. + * @param newSymbols desired DecimalFormatSymbols + * @see DecimalFormatSymbols + * @stable ICU 2.0 + */ + public void setDecimalFormatSymbols(DecimalFormatSymbols newSymbols) { + ((java.text.DecimalFormat)numberFormat).setDecimalFormatSymbols(newSymbols.dfs); + } + + + /** + * Get the positive prefix. + *
Examples: +123, $123, sFr123 + * @stable ICU 2.0 + */ + public String getPositivePrefix() { + return ((java.text.DecimalFormat)numberFormat).getPositivePrefix(); + } + + /** + * Set the positive prefix. + *
Examples: +123, $123, sFr123 + * @stable ICU 2.0 + */ + public void setPositivePrefix(String newValue) { + ((java.text.DecimalFormat)numberFormat).setPositivePrefix(newValue); + } + + /** + * Get the negative prefix. + *
Examples: -123, ($123) (with negative suffix), sFr-123 + * @stable ICU 2.0 + */ + public String getNegativePrefix () { + return ((java.text.DecimalFormat)numberFormat).getNegativePrefix(); + } + + /** + * Set the negative prefix. + *
Examples: -123, ($123) (with negative suffix), sFr-123 + * @stable ICU 2.0 + */ + public void setNegativePrefix (String newValue) { + ((java.text.DecimalFormat)numberFormat).setNegativePrefix(newValue); + } + + /** + * Get the positive suffix. + *
Example: 123% + * @stable ICU 2.0 + */ + public String getPositiveSuffix () { + return ((java.text.DecimalFormat)numberFormat).getPositiveSuffix(); + } + + /** + * Set the positive suffix. + *
Example: 123% + * @stable ICU 2.0 + */ + public void setPositiveSuffix (String newValue) { + ((java.text.DecimalFormat)numberFormat).setPositiveSuffix(newValue); + } + + /** + * Get the negative suffix. + *
Examples: -123%, ($123) (with positive suffixes) + * @stable ICU 2.0 + */ + public String getNegativeSuffix () { + return ((java.text.DecimalFormat)numberFormat).getNegativeSuffix(); + } + + /** + * Set the positive suffix. + *
Examples: 123% + * @stable ICU 2.0 + */ + public void setNegativeSuffix (String newValue) { + ((java.text.DecimalFormat)numberFormat).setNegativeSuffix(newValue); + } + + /** + * Get the multiplier for use in percent, permill, etc. + * For a percentage, set the suffixes to have "%" and the multiplier to be 100. + * (For Arabic, use arabic percent symbol). + * For a permill, set the suffixes to have "\u2031" and the multiplier to be 1000. + *
Examples: with 100, 1.23 -> "123", and "123" -> 1.23 + * @stable ICU 2.0 + */ + public int getMultiplier () { + return ((java.text.DecimalFormat)numberFormat).getMultiplier(); + } + + /** + * Set the multiplier for use in percent, permill, etc. + * For a percentage, set the suffixes to have "%" and the multiplier to be 100. + * (For Arabic, use arabic percent symbol). + * For a permill, set the suffixes to have "\u2031" and the multiplier to be 1000. + *
Examples: with 100, 1.23 -> "123", and "123" -> 1.23 + * @stable ICU 2.0 + */ + public void setMultiplier (int newValue) { + ((java.text.DecimalFormat)numberFormat).setMultiplier(newValue); + } + + /** + * Return the grouping size. Grouping size is the number of digits between + * grouping separators in the integer portion of a number. For example, + * in the number "123,456.78", the grouping size is 3. + * @see #setGroupingSize + * @see NumberFormat#isGroupingUsed + * @see DecimalFormatSymbols#getGroupingSeparator + * @stable ICU 2.0 + */ + public int getGroupingSize () { + return ((java.text.DecimalFormat)numberFormat).getGroupingSize(); + } + + /** + * Set the grouping size. Grouping size is the number of digits between + * grouping separators in the integer portion of a number. For example, + * in the number "123,456.78", the grouping size is 3. + * @see #getGroupingSize + * @see NumberFormat#setGroupingUsed + * @see DecimalFormatSymbols#setGroupingSeparator + * @stable ICU 2.0 + */ + public void setGroupingSize (int newValue) { + ((java.text.DecimalFormat)numberFormat).setGroupingSize(newValue); + } + + /** + * Allows you to get the behavior of the decimal separator with integers. + * (The decimal separator will always appear with decimals.) + *
Example: Decimal ON: 12345 -> 12345.; OFF: 12345 -> 12345 + * @stable ICU 2.0 + */ + public boolean isDecimalSeparatorAlwaysShown() { + return ((java.text.DecimalFormat)numberFormat).isDecimalSeparatorAlwaysShown(); + } + + /** + * Allows you to set the behavior of the decimal separator with integers. + * (The decimal separator will always appear with decimals.) + * + *
This only affects formatting, and only where + * there might be no digits after the decimal point, e.g., + * if true, 3456.00 -> "3,456." + * if false, 3456.00 -> "3456" + * This is independent of parsing. If you want parsing to stop at the decimal + * point, use setParseIntegerOnly. + * + *
Example: Decimal ON: 12345 -> 12345.; OFF: 12345 -> 12345 + * @stable ICU 2.0 + */ + public void setDecimalSeparatorAlwaysShown(boolean newValue) { + ((java.text.DecimalFormat)numberFormat).setDecimalSeparatorAlwaysShown(newValue); + } + + /** + * Standard override; no change in semantics. + * @stable ICU 2.0 + */ + public Object clone() { + return new DecimalFormatSymbols((java.text.DecimalFormatSymbols)numberFormat.clone()); + } + + /** + * Synthesizes a pattern string that represents the current state + * of this Format object. + * @see #applyPattern + * @stable ICU 2.0 + */ + public String toPattern() { + return ((java.text.DecimalFormat)numberFormat).toPattern(); + } + + /** + * Synthesizes a localized pattern string that represents the current + * state of this Format object. + * @see #applyPattern + * @stable ICU 2.0 + */ + public String toLocalizedPattern() { + return ((java.text.DecimalFormat)numberFormat).toLocalizedPattern(); + } + + + /** + * Apply the given pattern to this Format object. A pattern is a + * short-hand specification for the various formatting properties. + * These properties can also be changed individually through the + * various setter methods. + *
+ * There is no limit to integer digits are set + * by this routine, since that is the typical end-user desire; + * use setMaximumInteger if you want to set a real value. + * For negative numbers, use a second pattern, separated by a semicolon + *
Example "#,#00.0#" -> 1,234.56 + *
This means a minimum of 2 integer digits, 1 fraction digit, and + * a maximum of 2 fraction digits. + *
Example: "#,#00.0#;(#,#00.0#)" for negatives in parentheses. + *
In negative patterns, the minimum and maximum counts are ignored; + * these are presumed to be set in the positive pattern. + * @stable ICU 2.0 + */ + public void applyPattern(String pattern) { + ((java.text.DecimalFormat)numberFormat).applyPattern(pattern); + } + + /** + * Apply the given pattern to this Format object. The pattern + * is assumed to be in a localized notation. A pattern is a + * short-hand specification for the various formatting properties. + * These properties can also be changed individually through the + * various setter methods. + *
+ * There is no limit to integer digits are set + * by this routine, since that is the typical end-user desire; + * use setMaximumInteger if you want to set a real value. + * For negative numbers, use a second pattern, separated by a semicolon + *
Example "#,#00.0#" -> 1,234.56 + *
This means a minimum of 2 integer digits, 1 fraction digit, and + * a maximum of 2 fraction digits. + *
Example: "#,#00.0#;(#,#00.0#)" for negatives in parentheses. + *
In negative patterns, the minimum and maximum counts are ignored; + * these are presumed to be set in the positive pattern. + * @stable ICU 2.0 + */ + public void applyLocalizedPattern(String pattern) { + ((java.text.DecimalFormat)numberFormat).applyLocalizedPattern(pattern); + } +}