DecimalFormat

public class DecimalFormat
extends NumberFormat

Known Direct Subclasses CompactDecimalFormat CompactDecimalFormat CompactDecimalFormat生成缩略号码，适合在环境中显示将限制房地产。

[icu增强] ICU更换DecimalFormat 。 ICU特有的方法，字段和其他功能标记为“ [icu] ”。 DecimalFormat是格式为十进制数的NumberFormat的具体子类。 它具有多种功能，可以在任何语言环境中解析和格式化数字，包括支持西文，阿拉伯文或印度文数字。 它还支持不同类型的数字，包括整数（“123”），定点数字（“123.4”），科学记数法（“1.23E4”），百分比（“12％”）和货币金额（“123.00美元” ，“123.00美元”，“123.00美元”）。 所有这些口味都可以轻松本地化。

要获取NumberFormat的特定区域设置（包括默认区域设置），请调用NumberFormat的工厂方法之一，如getInstance() 。 除非你知道你在做什么，否则不要直接调用DecimalFormat构造函数，因为NumberFormat工厂方法可能会返回除DecimalFormat子类。 如果您需要自定义格式对象，请执行以下操作：

 NumberFormat f = NumberFormat.getInstance(loc);
 if (f instanceof DecimalFormat) {
     ((DecimalFormat) f).setDecimalSeparatorAlwaysShown(true);
 }

示例用法使用每种语言环境的本地化数字，货币和百分比格式打印出一个数字。

 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) {}
     }
 }

另一个例子使用getInstance（style）。
使用本地化号码，货币，百分比，科学，整数，iso货币和每种语言环境的复数货币格式打印出一个数字。

 ULocale locale = new ULocale("en_US");
 double myNumber = 1234.56;
 for (int j=NumberFormat.NUMBERSTYLE; j<=NumberFormat.PLURALCURRENCYSTYLE; ++j) {
     NumberFormat format = NumberFormat.getInstance(locale, j);
     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) {}
 }

Patterns

一个DecimalFormat由一个模式和一组符号组成 。 该模式可以直接使用applyPattern(String)来设置，或者间接使用操纵模式方面的其他API方法，例如最小数量的整数数字。 符号存储在DecimalFormatSymbols对象中。 使用NumberFormat工厂方法时，将从ICU的区域设置数据中读取模式和符号。

Special Pattern Characters

模式中的许多字符都是字面上的; 它们在分析过程中被匹配并且在格式化过程中输出不变。 另一方面，特殊字符代表其他字符，字符串或类别的字符。 例如，'＃'字符被替换为本地化数字。 替换字符通常与模式字符相同; 在美国的语言环境中，'，'分组字符被替换为'，'。 但是，替换仍在发生，如果符号被修改，分组字符会改变。 一些特殊字符会影响格式化程序的行为。 例如，如果看到百分比字符，则在显示之前将该值乘以100。

要将特殊字符作为文字插入模式，即没有任何特殊含义，必须引用该字符。 有一些例外情况如下所述。

此处列出的字符用于非本地化模式。 本地化模式使用从此格式化程序的DecimalFormatSymbols对象中取得的相应字符，而这些字符将失去其特殊状态。 货币符号和报价是两个例外，它们不是本地化的。

Symbol	Location	Localized?	Meaning
0	Number	Yes	Digit
1-9	Number	Yes	'1' through '9' indicate rounding.
@	Number	No	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	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 tripled, replaced by currency plural names, for example, "US dollar" or "US dollars" for America. 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	Pad escape, precedes pad character

DecimalFormat模式包含DecimalFormat和负面的子模式，例如“＃，## 0.00;（＃，## 0.00）”。 每个子模式都有一个前缀，一个数字部分和一个后缀。 如果没有明确的负子模式，则负子模式是正子模式前缀的本地化负号。 也就是说，仅“0.00”等于“0.00; -0.00”。 如果存在明确的负面子模式，则仅用于指定负面前缀和后缀; 负数子模式中将忽略数字位数，最小位数和其他特征。 这意味着“＃，## 0.0＃;（＃）”的结果与“＃，## 0.0＃;（＃，## 0.0＃）”的结果完全相同。

用于无穷大，数字，千位分隔符，小数点分隔符等的前缀，后缀和各种符号可以设置为任意值，并且在格式化过程中它们将正确显示。 但是，必须注意符号和字符串不冲突，否则解析将不可靠。 例如，对于parse(String) ，正面和负面前缀或后缀必须是不同的，才能区分正值和负值。 另一个例子是小数点分隔符和千位分隔符应该是不同的字符，否则解析将是不可能的。

分组分隔符是一个字符，用于分隔整数数字的集群以使大量数字更清晰易读。 它通常用于数以千计，但在某些地区，它将分隔数以万计。 分组大小是分组分隔符之间的位数，例如3表示“100,000,000”，4表示“1 0000 0000”。 实际上有两种不同的分组大小：一种用于最小有效整数数字， 主要分组大小 ，另一种用于所有其他分组大小 ， 次要分组大小 。 在大多数地区，这些都是一样的，但有时它们是不同的。 例如，如果主要分组间隔为3，次要分组间隔为2，则这对应于模式“＃，##，## 0”，并且数字123456789被格式化为“12,34,56,789”。 如果一个模式包含多个分组分隔符，则最后一个与整数末尾之间的间隔将定义主要分组大小，最后两个之间的间隔将定义次要分组大小。 所有其他人都会被忽略，所以“＃，##，###，####”==“###，###，####”==“##，＃，###，＃ ###”。

非法模式（例如“＃。＃。＃”或“＃。###，###”）将导致 DecimalFormat向 IllegalArgumentException发送一条描述该问题的消息。

Pattern BNF

 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
 

在上面的BNF语法中没有指出：

• The grouping separator ',' can occur inside the integer and sigDigits elements, between any two pattern characters of that element, as long as the integer or sigDigits element is not followed by the exponent element.
• Two grouping intervals are recognized: That between the decimal point and the first grouping symbol, and that between the first and second grouping symbols. These intervals are identical in most locales, but in some locales they differ. For example, the pattern "#,##,###" formats the number 123456789 as "12,34,56,789".
• The pad specifier padSpec may appear before the prefix, after the prefix, before the suffix, after the suffix, or not at all.
• In place of '0', the digits '1' through '9' may be used to indicate a rounding increment.

Parsing

DecimalFormat解析所有代表十进制数字的Unicode字符，如digit(int)所定义。 另外， DecimalFormat还将DecimalFormatSymbols对象中定义的以本地零位数开始的十个连续字符识别为数字。 在格式化过程中，将DecimalFormatSymbols基于DecimalFormatSymbols的数字。

在分析过程中，分组分隔符将被忽略。

对于货币解析，格式器能够解析每种货币风格格式，而不管格式器使用哪种风格。 例如，从NumberFormat.getInstance（ULocale，NumberFormat.CURRENCYSTYLE）获取的格式化程序实例可以解析诸如“USD1.00”和“3.00美元”之类的格式。

如果parse(String, ParsePosition)未能解析字符串，则返回null并保持解析位置不变。 的便利方法parse(String)表示通过投掷失败解析ParseException 。

解析极大或小的绝对值（如1.0E10000或1.0E-10000）需要大量的内存分配来表示分析的数字。 这样的输入可能会带来DoS攻击的风险。 为了防止由这样的输入触发巨大的内存分配， DecimalFormat内部最大小数位数限制为1000.因此，以普通十进制表示形式（非指数）产生的超过1000个数字的输入字符串将被视为溢出（正/负无限）或下溢（+ 0.0 / -0.0）。

Formatting

格式化由几个参数引导，所有这些参数都可以使用模式或使用API来指定。 以下描述适用于不使用scientific notation或significant digits的格式。

• If the number of actual integer digits exceeds the maximum integer digits, then only the least significant digits are shown. For example, 1997 is formatted as "97" if the maximum integer digits is set to 2.
• If the number of actual integer digits is less than the minimum integer digits, then leading zeros are added. For example, 1997 is formatted as "01997" if the minimum integer digits is set to 5.
• If the number of actual fraction digits exceeds the maximum fraction digits, then half-even rounding it performed to the maximum fraction digits. For example, 0.125 is formatted as "0.12" if the maximum fraction digits is 2. This behavior can be changed by specifying a rounding increment and a rounding mode.
• If the number of actual fraction digits is less than the minimum fraction digits, then trailing zeros are added. For example, 0.125 is formatted as "0.1250" if the mimimum fraction digits is set to 4.
• Trailing fractional zeros are not displayed if they occur j positions after the decimal, where j is less than the maximum fraction digits. For example, 0.10004 is formatted as "0.1" if the maximum fraction digits is four or less.

特殊的价值

NaN表示为单个字符，通常为\uFFFD 。 该字符由DecimalFormatSymbols对象决定。 这是不使用前缀和后缀的唯一值。

Infinity表示为单个字符，通常为\u221E ，应用正数或负数的前缀和后缀。 无穷大字符由DecimalFormatSymbols对象确定。

Scientific Notation

科学记数法中的数字表示为尾数和十的乘方的乘积，例如，1234可以表示为1.234×10 ³ 。 尾数通常在半开区间[1.0,10.0）或有时[0.0,1.0]，但不一定是。 DecimalFormat支持任意DecimalFormat 。 可以指示DecimalFormat通过API或通过模式使用科学记数法。 在一种模式中，紧接着一个或多个数字字符的指数字符表示科学记数法。 例如：“0。### E0”将数字1234格式化为“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". To prefix positive exponents with a localized plus sign, specify '+' between the exponent and the digits: "0.###E+0" will produce formats "1E+1", "1E+0", "1E-1", etc. (In localized patterns, use the localized plus sign rather than '+'.)
• The minimum number of integer digits is achieved by adjusting the exponent. Example: 0.00123 formatted with "00.###E0" yields "12.3E-4". This only happens if there is no maximum number of integer digits. If there is a maximum, then the minimum number of integer digits is fixed at one.
• The maximum number of integer digits, if present, specifies the exponent grouping. The most common use of this is to generate engineering notation, in which the exponent is a multiple of three, e.g., "##0.###E0". The number 12345 is formatted using "##0.####E0" as "12.345E3".
• When using scientific notation, the formatter controls the digit counts using significant digits logic. The maximum number of significant digits limits the total number of integer and fraction digits that will be shown in the mantissa; it does not affect parsing. For example, 12345 formatted with "##0.##E0" is "12.3E3". See the section on significant digits for more details.
• The number of significant digits shown is determined as follows: If areSignificantDigitsUsed() returns false, then the minimum number of significant digits shown is one, and the maximum number of significant digits shown is the sum of the minimum integer and maximum fraction digits, and is unaffected by the maximum integer digits. If this sum is zero, then all significant digits are shown. If areSignificantDigitsUsed() returns true, then the significant digit counts are specified by getMinimumSignificantDigits() and getMaximumSignificantDigits(). In this case, the number of integer digits is fixed at one, and there is no exponent grouping.
• Exponential patterns may not contain grouping separators.

Significant Digits

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

• Significant digit counts may be expressed using patterns that specify a minimum and maximum number of significant digits. These are indicated by the '@' 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".
• If a pattern uses significant digits, it may not contain a decimal separator, nor the '0' pattern character. Patterns such as "@00" or "@.###" are disallowed.
• Any number of '#' 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.
• In order to enable significant digits formatting, use a pattern containing the '@' pattern character. Alternatively, call setSignificantDigitsUsed(true).
• In order to disable significant digits formatting, use a pattern that does not contain the '@' pattern character. Alternatively, call setSignificantDigitsUsed(false).
• The number of significant digits has no effect on parsing.
• Significant digits may be used together with exponential notation. Such patterns are equivalent to a normal exponential pattern with a minimum and maximum integer digit count of one, a minimum fraction digit count of getMinimumSignificantDigits() - 1, and a maximum fraction digit count of getMaximumSignificantDigits() - 1. For example, the pattern "@@###E0" is equivalent to "0.0###E0".
• If signficant digits are in use, then the integer and fraction digit counts, as set via the API, are ignored. If significant digits are not in use, then the signficant digit counts, as set via the API, are ignored.

Padding

DecimalFormat载体填充的结果format(BigDecimal)到特定的宽度。 填充可以通过API或通过模式语法指定。 在一个模式中，填充字符转义字符，后跟一个填充字符，使填充分析和格式化。 pad转义字符是非本地化模式中的'*'，可以使用setPadEscape(char)进行本地化。 例如， "$*x#,##0.00"格式123至"$xx123.00"和1234至"$1,234.00" 。

• When padding is in effect, the width of the positive subpattern, including prefix and suffix, determines the format width. For example, in the pattern "* #0 o''clock", the format width is 10.
• The width is counted in 16-bit code units (Java chars).
• Some parameters which usually do not matter have meaning when padding is used, because the pattern width is significant with padding. In the pattern "* ##,##,#,##0.##", the format width is 14. The initial characters "##,##," do not affect the grouping size or maximum integer digits, but they do affect the format width.
• Padding may be inserted at one of four locations: before the prefix, after the prefix, before the suffix, or after the suffix. If padding is specified in any other location, applyPattern(String) throws an IllegalArgumentException. If there is no prefix, before the prefix and after the prefix are equivalent, likewise for the suffix.
• When specified in a pattern, the 16-bit 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.

四舍五入

DecimalFormat支持对特定增量进行四舍五入。 例如，1230舍入到最接近的50是1250. 1.234舍入到最接近的0.65是1.3。 舍入增量可以通过API或模式指定。 要在模式中指定舍入增量，请在模式本身中包含增量。 “＃，＃50”指定50的舍入增量。“＃，## 0.05”指定0.05的舍入增量。

• Rounding only affects the string produced by formatting. It does not affect parsing or change any numerical values.
• A rounding mode determines how values are rounded; see the BigDecimal documentation for a description of the modes. Rounding increments specified in patterns use the default mode, ROUND_HALF_EVEN.
• Some locales use rounding in their currency formats to reflect the smallest currency denomination.
• In a pattern, digits '1' through '9' specify rounding, but otherwise behave identically to digit '0'.

Synchronization

DecimalFormat对象不同步。 多个线程不应该同时访问一个格式化程序。

Summary

Inherited constants

From class android.icu.text.NumberFormat int ACCOUNTINGCURRENCYSTYLE [icu]常量，指定使用货币符号表示记帐货币的格式货币格式，例如：“（$ 3.00）”，而不是“ - $ 3.00”（ CURRENCYSTYLE ）。 int CASHCURRENCYSTYLE [icu]用于指定使用货币ISO代码表示货币的格式的货币现金风格的常量，例如：“NT $ 3”而不是“NT $ 3.23”。 int CURRENCYSTYLE [icu]常量，用于指定格式的通用货币风格。 int FRACTION_FIELD 用于构造FieldPosition对象的字段常量。 int INTEGERSTYLE [icu]用于指定整数数字样式格式的常数。 int INTEGER_FIELD 用于构造FieldPosition对象的字段常量。 int ISOCURRENCYSTYLE [icu]常量，用于指定使用货币ISO代码表示货币的格式的货币格式，例如：“USD3.00”。 int NUMBERSTYLE [icu]常量来指定格式的正常数字样式。 int PERCENTSTYLE [icu]常量，用于指定显示百分比的格式样式。 int PLURALCURRENCYSTYLE [icu]常数，用于指定使用货币长名称以多种格式表示货币的格式的货币格式，例如“3.00美元”。 int SCIENTIFICSTYLE [icu]用于指定显示科学编号的格式样式的常量。

Inherited methods
From class android.icu.text.NumberFormat Object clone() 覆盖克隆。 boolean equals(Object obj) 覆盖等于。 abstract StringBuffer format(BigInteger number, StringBuffer toAppendTo, FieldPosition pos) [icu]格式化BigInteger。 abstract StringBuffer format(BigDecimal number, StringBuffer toAppendTo, FieldPosition pos) [icu]格式化ICU BigDecimal。 StringBuffer format(Object number, StringBuffer toAppendTo, FieldPosition pos) 格式化数字并将结果文本附加到给定的字符串缓冲区。 final String format(BigDecimal number) 便捷方法来格式化BigDecimal。 abstract StringBuffer format(double number, StringBuffer toAppendTo, FieldPosition pos) 格式专业化。 final String format(BigInteger number) [icu]格式化BigInteger的便捷方法。 abstract StringBuffer format(BigDecimal number, StringBuffer toAppendTo, FieldPosition pos) [icu]格式化BigDecimal。 final String format(BigDecimal number) [icu]格式化ICU BigDecimal的便捷方法。 final String format(double number) 格式专业化。 final String format(long number) 格式专业化。 StringBuffer format(CurrencyAmount currAmt, StringBuffer toAppendTo, FieldPosition pos) [icu]格式CurrencyAmount。 final String format(CurrencyAmount currAmt) [icu]格式化CurrencyAmount的便捷方法。 abstract StringBuffer format(long number, StringBuffer toAppendTo, FieldPosition pos) 格式专业化。 static Locale[] getAvailableLocales() 返回NumberFormats可用的语言环境列表。 DisplayContext getContext(DisplayContext.Type type) [icu]获取指定DisplayContext.Type的格式化程序的DisplayContext值，例如CAPITALIZATION。 Currency getCurrency() 返回用于显示货币金额的 Currency对象。 static NumberFormat getCurrencyInstance(Locale inLocale) 返回指定语言环境的货币格式。 static NumberFormat getCurrencyInstance(ULocale inLocale) [icu]返回指定语言环境的货币格式。 static final NumberFormat getCurrencyInstance() 返回当前默认 FORMAT区域设置的货币格式。 static final NumberFormat getInstance() 返回当前默认 FORMAT语言环境的默认数字格式。 static NumberFormat getInstance(Locale inLocale) 返回指定语言环境的默认数字格式。 static NumberFormat getInstance(ULocale desiredLocale, int choice) 返回特定区域设置的特定样式数字格式。 static NumberFormat getInstance(Locale inLocale, int style) [icu]返回特定区域设置的特定样式编号格式。 static NumberFormat getInstance(ULocale inLocale) [icu]返回指定语言环境的默认数字格式。 static final NumberFormat getInstance(int style) [icu]返回默认 FORMAT语言环境的特定样式编号格式。 static NumberFormat getIntegerInstance(ULocale inLocale) [icu]返回指定语言环境的整数数字格式。 static final NumberFormat getIntegerInstance() 返回当前默认 FORMAT语言环境的整数数字格式。 static NumberFormat getIntegerInstance(Locale inLocale) 返回指定语言环境的整数数字格式。 int getMaximumFractionDigits() 返回数字的小数部分中允许的最大位数。 int getMaximumIntegerDigits() 返回数字整数部分允许的最大位数。 int getMinimumFractionDigits() 返回数字的小数部分中允许的最小位数。 int getMinimumIntegerDigits() 返回数字整数部分允许的最小位数。 static NumberFormat getNumberInstance(ULocale inLocale) [icu]返回指定语言环境的通用数字格式。 static final NumberFormat getNumberInstance() 返回当前默认 FORMAT区域设置的通用数字格式。 static NumberFormat getNumberInstance(Locale inLocale) 返回指定语言环境的通用数字格式。 static String getPattern(ULocale forLocale, int choice) 返回提供的语言环境和选择的模式。 static final NumberFormat getPercentInstance() 返回当前默认 FORMAT语言环境的百分比格式。 static NumberFormat getPercentInstance(Locale inLocale) 返回指定语言环境的百分比格式。 static NumberFormat getPercentInstance(ULocale inLocale) [icu]返回指定语言环境的百分比格式。 int getRoundingMode() 返回此NumberFormat中使用的舍入模式。 static NumberFormat getScientificInstance(ULocale inLocale) [icu]返回指定语言环境的科学格式。 static NumberFormat getScientificInstance(Locale inLocale) [icu]返回指定语言环境的科学格式。 static final NumberFormat getScientificInstance() [icu]返回当前默认 FORMAT语言环境的科学格式。 int hashCode() 重写hashCode。 boolean isGroupingUsed() 如果以此格式使用分组，则返回true。 boolean isParseIntegerOnly() 如果此格式仅将数字解析为整数，则返回true。 boolean isParseStrict() [icu]返回严格解析是否有效。 Number parse(String text) 从给定字符串的开头解析文本以产生一个数字。 abstract Number parse(String text, ParsePosition parsePosition) 如果可能的话返回一个Long（例如，在[Long.MIN_VALUE，Long.MAX_VALUE]范围内且没有小数），否则返回Double。 CurrencyAmount parseCurrency(CharSequence text, ParsePosition pos) 将给定字符串中的文本解析为CurrencyAmount。 final Object parseObject(String source, ParsePosition parsePosition) 解析字符串中的文本以产生一个数字。 void setContext(DisplayContext context) [icu]在格式化程序中设置特定的DisplayContext值，例如CAPITALIZATION_FOR_STANDALONE。 void setCurrency(Currency theCurrency) 设置用于显示货币金额的 Currency对象。 void setGroupingUsed(boolean newValue) 设置是否以此格式使用分组。 void setMaximumFractionDigits(int newValue) 设置数字的小数部分允许的最大位数。 void setMaximumIntegerDigits(int newValue) 设置数字整数部分允许的最大位数。 void setMinimumFractionDigits(int newValue) 设置数字的小数部分中允许的最小位数。 void setMinimumIntegerDigits(int newValue) 设置数字整数部分允许的最小位数。 void setParseIntegerOnly(boolean value) 设置数字是否应该仅被解析为整数。 void setParseStrict(boolean value) [icu]设置严格分析是否有效。 void setRoundingMode(int roundingMode) 设置此NumberFormat中使用的舍入模式。
From class java.text.Format Object clone() 创建并返回此对象的副本。 final String format(Object obj) 格式化一个对象来产生一个字符串。 abstract StringBuffer format(Object obj, StringBuffer toAppendTo, FieldPosition pos) 格式化对象并将结果文本附加到给定的字符串缓冲区。 AttributedCharacterIterator formatToCharacterIterator(Object obj) 格式化产生 AttributedCharacterIterator的对象。 Object parseObject(String source) 从给定字符串的开头解析文本以生成一个对象。 abstract Object parseObject(String source, ParsePosition pos) 分析字符串中的文本以生成对象。
From class java.lang.Object Object clone() 创建并返回此对象的副本。 boolean equals(Object obj) 指示其他某个对象是否“等于”这一个。 void finalize() 当垃圾收集确定没有更多对该对象的引用时，由对象上的垃圾回收器调用。 final Class<?> getClass() 返回此 Object的运行时类。 int hashCode() 返回对象的哈希码值。 final void notify() 唤醒正在等待该对象监视器的单个线程。 final void notifyAll() 唤醒在该对象监视器上等待的所有线程。 String toString() 返回对象的字符串表示形式。 final void wait(long millis, int nanos) 导致当前线程等待，直到另一个线程为该对象调用 notify()方法或 notifyAll()方法，或者某个其他线程中断当前线程或经过了一定的实时时间。 final void wait(long millis) 导致当前线程等待，直到另一个线程调用此对象的 notify()方法或 notifyAll()方法或经过了指定的时间量。 final void wait() 使当前线程等待，直到另一个线程调用此对象的 notify()方法或 notifyAll()方法。

Constants

int PAD_AFTER_PREFIX

int PAD_AFTER_SUFFIX

int PAD_BEFORE_PREFIX

int PAD_BEFORE_SUFFIX

Public constructors

DecimalFormat ()

DecimalFormat (String pattern)

DecimalFormat (String pattern, 
                DecimalFormatSymbols symbols)

DecimalFormat (String pattern, 
                DecimalFormatSymbols symbols, 
                CurrencyPluralInfo infoInput, 
                int style)

Public methods

void applyLocalizedPattern (String pattern)

void applyPattern (String pattern)

boolean areSignificantDigitsUsed ()

Object clone ()

boolean equals (Object obj)

StringBuffer format (BigInteger number, 
                StringBuffer result, 
                FieldPosition fieldPosition)

StringBuffer format (BigDecimal number, 
                StringBuffer result, 
                FieldPosition fieldPosition)

StringBuffer format (double number, 
                StringBuffer result, 
                FieldPosition fieldPosition)

StringBuffer format (BigDecimal number, 
                StringBuffer result, 
                FieldPosition fieldPosition)

StringBuffer format (long number, 
                StringBuffer result, 
                FieldPosition fieldPosition)

AttributedCharacterIterator formatToCharacterIterator (Object obj)

CurrencyPluralInfo getCurrencyPluralInfo ()

Currency.CurrencyUsage getCurrencyUsage ()

DecimalFormatSymbols getDecimalFormatSymbols ()

int getFormatWidth ()

int getGroupingSize ()

MathContext getMathContext ()

MathContext getMathContextICU ()

int getMaximumSignificantDigits ()

byte getMinimumExponentDigits ()

int getMinimumSignificantDigits ()

int getMultiplier ()

String getNegativePrefix ()

String getNegativeSuffix ()

char getPadCharacter ()

int getPadPosition ()

int getParseMaxDigits ()

String getPositivePrefix ()

String getPositiveSuffix ()

BigDecimal getRoundingIncrement ()

int getRoundingMode ()

int getSecondaryGroupingSize ()

int hashCode ()

boolean isDecimalPatternMatchRequired ()

boolean isDecimalSeparatorAlwaysShown ()

boolean isExponentSignAlwaysShown ()

boolean isParseBigDecimal ()

boolean isScientificNotation ()

Number parse (String text, 
                ParsePosition parsePosition)

CurrencyAmount parseCurrency (CharSequence text, 
                ParsePosition pos)

void setCurrency (Currency theCurrency)

void setCurrencyPluralInfo (CurrencyPluralInfo newInfo)

void setCurrencyUsage (Currency.CurrencyUsage newUsage)

void setDecimalFormatSymbols (DecimalFormatSymbols newSymbols)

void setDecimalPatternMatchRequired (boolean value)

void setDecimalSeparatorAlwaysShown (boolean newValue)

void setExponentSignAlwaysShown (boolean expSignAlways)

void setFormatWidth (int width)

void setGroupingSize (int newValue)

void setMathContext (MathContext newValue)

void setMathContextICU (MathContext newValue)

void setMaximumFractionDigits (int newValue)

void setMaximumIntegerDigits (int newValue)

void setMaximumSignificantDigits (int max)

void setMinimumExponentDigits (byte minExpDig)

void setMinimumFractionDigits (int newValue)

void setMinimumIntegerDigits (int newValue)

void setMinimumSignificantDigits (int min)

void setMultiplier (int newValue)

void setNegativePrefix (String newValue)

void setNegativeSuffix (String newValue)

void setPadCharacter (char padChar)

void setPadPosition (int padPos)

void setParseBigDecimal (boolean value)

void setParseMaxDigits (int newValue)

void setPositivePrefix (String newValue)

void setPositiveSuffix (String newValue)

void setRoundingIncrement (BigDecimal newValue)

void setRoundingIncrement (BigDecimal newValue)

void setRoundingIncrement (double newValue)

void setRoundingMode (int roundingMode)

void setScientificNotation (boolean useScientific)

void setSecondaryGroupingSize (int newValue)

void setSignificantDigitsUsed (boolean useSignificantDigits)

String toLocalizedPattern ()

String toPattern ()