DecimalFormat详解

如下：
/**
* 将double值转为显示格式
*
* @param f
* @return
*/
public static String toDoubleView(double f) {
BigDecimal b = new BigDecimal(f);
f = b.setScale(2, BigDecimal.ROUND_HALF_UP).doubleValue();

    DecimalFormat fnum = new DecimalFormat("##0.00");
    return fnum.format(f);
}

A concrete subclass of NumberFormat that formats decimal numbers. It has a variety of features designed to make it possible to parse and format numbers in any locale, including support for Western, Arabic, or Indic digits. It also supports different flavors of numbers, including integers (“123”), fixed-point numbers (“123.4”), scientific notation (“1.23E4”), percentages (“12%”), and currency amounts (“$123”). All of these flavors can be easily localized.

This is an enhanced version of DecimalFormat that is based on the standard version in the RI. New or changed functionality is labeled NEW.

To obtain a NumberFormat for a specific locale (including the default locale), call one of NumberFormat’s factory methods such as NumberFormat.getInstance. Do not call the DecimalFormat constructors directly, unless you know what you are doing, since the 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);
}

Patterns
A DecimalFormat consists of a pattern and a set of symbols. The pattern may be set directly using applyPattern(String), 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 DecimalFormatSymbols object. When using the NumberFormat factory methods, the pattern and symbols are read from ICU’s locale data.

Special Pattern Characters
Many characters in a pattern are taken literally; they are matched during parsing and are written out unchanged during formatting. On the other hand, special characters 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 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.
@ Number No NEW Significant digit.

Number Yes Digit, leading zeroes are not shown.

. 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. Does not need to be quoted in prefix or suffix.
+ Exponent Yes NEW Prefix positive exponents with localized plus sign. Does not need to 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 (\u005Cu2030) Prefix or suffix Yes Multiply by 1000 and show as per mille.
\u00A4 (\u005Cu00A4) 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 positive 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. This means that “#,##0.0#;(#)” produces 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 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 is 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 “#,##,###,####”, “###,###,####” and “##,#,###,####” produce the same result.

Illegal patterns, such as “#.#.#” or “#.###,###”, will cause DecimalFormat to throw an IllegalArgumentException with a message that describes the problem.

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

The first subpattern is for positive numbers. The second (optional) subpattern is for negative numbers.
Not indicated in the BNF syntax above:

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.
NEW Two grouping intervals are recognized: The one between the decimal point and the first grouping symbol and the one 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”.
NEW The pad specifier padSpec may appear before the prefix, after the prefix, before the suffix, after the suffix or not at all.
Parsing
DecimalFormat parses all Unicode characters that represent decimal digits, as defined by Character.digit(int, int). In addition, DecimalFormat also recognizes as digits the ten consecutive characters starting with the localized zero digit defined in the DecimalFormatSymbols object. During formatting, the DecimalFormatSymbols-based digits are written out.

During parsing, grouping separators are ignored.

If parse(String, ParsePosition) fails to parse a string, it returns null and leaves the parse position unchanged.

Formatting
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.

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 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 minimum integer digits is set to 5.
If the number of actual fraction digits exceeds the maximum fraction digits, then half-even rounding is performed to the maximum fraction digits. For example, 0.125 is formatted as “0.12” if the maximum fraction digits is 2.
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 minimum 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.
Special Values

NaN is represented as a single character, typically \u005cuFFFD. This character is determined by the DecimalFormatSymbols object. This is the only value for which the prefixes and suffixes are not used.

Infinity is represented as a single character, typically \u005cu221E, with the positive or negative prefixes and suffixes applied. The infinity character is determined by the 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 does not need to 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”.

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 no significant digits are used in the pattern then the minimum number of significant digits shown is one, the maximum number of significant digits shown is the sum of the minimum integer and maximum fraction digits, and it is unaffected by the maximum integer digits. If this sum is zero, then all significant digits are shown. If significant digits are used in the pattern then the number of integer digits is fixed at one and there is no exponent grouping.
Exponential patterns may not contain grouping separators.
NEW Significant Digits
DecimalFormat has two ways of controlling how many digits are shown: (a) significant digit counts or (b) integer and fraction digit counts. Integer and fraction digit counts are described above. When a formatter uses 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 as many integer and fraction digits as 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

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 digit counts, but may be used to position grouping separators. For example, “#,#@#” indicates a minimum of one significant digit, 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.
In order to disable significant digits formatting, use a pattern that does not contain the ‘@’ pattern character.
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 the number of ‘@’ characters in the pattern - 1, and a maximum fraction digit count of the number of ‘@’ and ‘#’ characters in the pattern - 1. For example, the pattern “@@###E0” is equivalent to “0.0###E0”.
If significant digits are in use then the integer and fraction digit counts, as set via the API, are ignored.
NEW Padding
DecimalFormat supports padding the result of 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. For example, “*x#,##0.00" formats 123 to "xx123.00”, and 1234 to “$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 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.
Serialization
Features marked as NEW and patterns that use characters not documented above are unlikely to serialize/deserialize correctly.

Synchronization
DecimalFormat objects are not synchronized. Multiple threads should not access one formatter concurrently.

See Also:
Format
NumberFormat

DecimalFormat 是 NumberFormat 的一个具体子类，用于格式化十进制数字。该类设计有各种功能，使其能够解析和格式化任意语言环境中的数，包括对西方语言、阿拉伯语和印度语数字的支持。它还支持不同类型的数，包括整数 (123)、定点数 (123.4)、科学记数法表示的数 (1.23E4)、百分数 (12%) 和金额 ($123)。所有这些内容都可以本地化。

要获取具体语言环境的 NumberFormat（包括默认语言环境），可调用 NumberFormat 的某个工厂方法，如 getInstance()。通常不直接调用 DecimalFormat 的构造方法，因为 NumberFormat 的工厂方法可能返回不同于 DecimalFormat 的子类。如果需要自定义格式对象，可执行：

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

DecimalFormat 包含一个模式 和一组符号。可直接使用 applyPattern() 或间接使用 API 方法来设置模式。符号存储在 DecimalFormatSymbols 对象中。使用 NumberFormat 工厂方法时，可从已本地化的 ResourceBundle 中读取模式和符号。

模式

DecimalFormat 模式具有下列语法：
模式：
正数模式
正数模式；负数模式
正数模式：
前缀opt 数字后缀opt
负数模式：
前缀opt 数字后缀opt
前缀：
除 \uFFFE、\uFFFF 和特殊字符以外的所有 Unicode 字符
后缀：
除 \uFFFE、\uFFFF 和特殊字符以外的所有 Unicode 字符
数字：
整数指数opt
整数。小数指数opt
整数：
最小整数
#

整数

, 整数

最小整数：
0
0 最小整数
0 , 最小整数
小数：
最小小数opt 可选小数opt
最小小数：
0 最小小数opt
可选小数：

可选小数opt

指数：
E 最小指数
最小指数：
0 最小指数opt

DecimalFormat 模式包含正数和负数子模式，例如 “#,##0.00;(#,##0.00)”。每个子模式都有前缀、数字部分和后缀。负数子模式是可选的；如果存在，则将用已本地化的减号（在多数语言环境中是 ‘-‘）作为前缀的正数子模式用作负数子模式。也就是说，单独的 “0.00” 等效于 “0.00;-0.00”。如果存在显式的负数子模式，则它仅指定负数前缀和后缀；数字位数、最小位数，其他特征都与正数模式相同。这意味着 “#,##0.0#;(#)” 的行为与 “#,##0.0#;(#,##0.0#)” 完全相同。

用于无穷大值、数字、千位分隔符、小数分隔符等的前缀、后缀和各种符号可设置为任意值，并且能在格式化期间正确显示。但是，必须注意不要让符号和字符串发生冲突，否则解析是不可靠的。例如，为了让 DecimalFormat.parse() 能够区分正数和负数，正数和负数前缀或后缀必须是不同的。（如果它们相同，则 DecimalFormat 的行为就如同未指定负数子模式一样。）另一个示例是小数分隔符和千位分隔符应该是不同的字符，否则将不可能进行解析。

分组分隔符通常用于千位，但是在某些国家/地区中它用于分隔万位。分组大小是分组字符之间的固定数字位数，例如 100,000,000 是 3，而 1,0000,0000 则是 4。如果使用具有多个分组字符的模式，则最后一个分隔符和整数结尾之间的间隔才是使用的分组大小。所以 “#,##,###,####” == “######,####” == “##,####,####”。

特殊模式字符

模式中的很多字符都是按字面解释的；在解析期间对其进行匹配，在格式化期间则不经改变地输出。另一方面，特殊字符代表了其他字符、字符串或字符类。如果要将其作为字面量出现在前缀或后缀中，那么除非另行说明，否则必须对其加引号。

下列字符用在非本地化的模式中。已本地化的模式使用从此格式器的 DecimalFormatSymbols 对象中获得的相应字符，这些字符已失去其特殊状态。两种例外是货币符号和引号，不将其本地化。

符号 位置 本地化？ 含义
0 数字 是 阿拉伯数字

数字字 是 阿拉伯数字，如果不存在则显示为 0

. 数字 是 小数分隔符或货币小数分隔符
- 数字 是 减号
, 数字 是 分组分隔符
E 数字 是 分隔科学计数法中的尾数和指数。在前缀或后缀中无需加引号。
; 子模式边界 是 分隔正数和负数子模式
% 前缀或后缀 是 乘以 100 并显示为百分数
\u2030 前缀或后缀 是 乘以 1000 并显示为千分数
¤ (\u00A4) 前缀或后缀 否 货币记号，由货币符号替换。如果两个同时出现，则用国际货币符号替换。如果出现在某个模式中，则使用货币小数分隔符，而不使用小数分隔符。
’ 前缀或后缀 否 用于在前缀或或后缀中为特殊字符加引号，例如 “’#’#” 将 123 格式化为 “#123”。要创建单引号本身，请连续使用两个单引号：”# o”clock”。
科学计数法

科学计数法中的数表示为一个尾数和一个 10 的几次幂的乘积，例如可将 1234 表示为 1.234 x 10^3。尾数的范围通常是 1.0 <= x < 10.0，但并非必需如此。可指示 DecimalFormat 仅通过某个模式 来格式化和解析科学计数法表示的数；目前没有创建科学计数法格式的工厂方法。在这个模式中，指数字符后面紧跟着一个或多个数字字符即指示科学计数法。示例：”0.###E0” 将数字 1234 格式化为 “1.234E3”。

指数字符后面的数字位数字符数给出了最小的指数位数。没有最大值。使用本地化的减号来格式化负数指数，不 使用模式中的前缀和后缀。这就允许存在诸如 “0.###E0 m/s” 等此类的模式。
最小和最大整数数字位数一起进行解释：
如果最大整数数字位数大于其最小整数数字位数并且大于 1，则强制要求指数为最大整数数字位数的倍数，并将最小整数数字位数解释为 1。最常见的用法是生成工程计数法，其中指数是 3 的倍数，如 “##0.#####E0”。使用此模式时，数 12345 格式化为 “12.345E3”，123456 则格式化为 “123.456E3”。
否则通过调整指数来得到最小整数数字位数。示例：使用 “00.###E0” 格式化 0.00123 时得到 “12.3E-4”。
尾数中的有效位数是最小整数 和最大小数 位数的和，不受最大整数位数的影响。例如，使用 “##0.##E0” 格式化 12345 得到 “12.3E3”。要显示所有位数，请将有效位数计数设置为零。有效位数不会影响解析。
指数模式可能不包含分组分隔符。
舍入

DecimalFormat 提供 RoundingMode 中定义的舍入模式进行格式化。默认情况下，它使用 RoundingMode.HALF_EVEN。
阿拉伯数字

为了进行格式化，DecimalFormat 使用 DecimalFormatSymbols 对象中所定义的、从已本地化的阿拉伯数字 0 开始的 10 个连续字符作为阿拉伯数字。为了进行解析，可识别 Character.digit 所定义的这些阿拉伯数字和所有 Unicode 十进制阿拉伯数字。
特殊值

NaN 被格式化为一个字符串，通常具有单个字符 \uFFFD。此字符串由 DecimalFormatSymbols 对象所确定。这是唯一不使用前缀和后缀的值。

无穷大的值被格式化为一个字符串，通常具有单个字符 \u221E，具有正数或负数前缀和后缀。无穷大值的字符串由 DecimalFormatSymbols 对象所确定。

将负零（”-0”）解析为

如果 isParseBigDecimal() 为 true，则为 BigDecimal(0)，
如果 isParseBigDecimal() 为 false 并且 isParseIntegerOnly() 为 true，则为 Long(0)，
如果 isParseBigDecimal() 和 isParseIntegerOnly() 均为 false，则为 Double(-0.0)。
同步

DecimalFormat 通常不是同步的。建议为每个线程创建独立的格式实例。如果多个线程同时访问某个格式，则必须保持外部同步。

示例

// Print out a number using the localized number, integer, currency,
// and percent format for each locale
Locale[] locales = NumberFormat.getAvailableLocales();
double myNumber = -1234.56;
NumberFormat form;
for (int j=0; j<4; ++j) {
System.out.println(“FORMAT”);
for (int i = 0; i < locales.length; ++i) {
if (locales[i].getCountry().length() == 0) {
continue; // Skip language-only locales
}
System.out.print(locales[i].getDisplayName());
switch (j) {
case 0:
form = NumberFormat.getInstance(locales[i]); break;
case 1:
form = NumberFormat.getIntegerInstance(locales[i]); break;
case 2:
form = NumberFormat.getCurrencyInstance(locales[i]); break;
default:
form = NumberFormat.getPercentInstance(locales[i]); break;
}
if (form instanceof DecimalFormat) {
System.out.print(“: ” + ((DecimalFormat) form).toPattern());
}
System.out.print(” -> ” + form.format(myNumber));
try {
System.out.println(” -> ” + form.parse(form.format(myNumber)));
} catch (ParseException e) {}
}
}

另请参见：
Java Tutorial, NumberFormat, DecimalFormatSymbols, ParsePosition, 序列化表格

嵌套类摘要

从类 java.text.NumberFormat 继承的嵌套类/接口
NumberFormat.Field

字段摘要

从类 java.text.NumberFormat 继承的字段
FRACTION_FIELD, INTEGER_FIELD

构造方法摘要
DecimalFormat()
使用默认模式和默认语言环境的符号创建一个 DecimalFormat。
DecimalFormat(String pattern)
使用给定的模式和默认语言环境的符号创建一个 DecimalFormat。
DecimalFormat(String pattern, DecimalFormatSymbols symbols)
使用给定的模式和符号创建一个 DecimalFormat。

方法摘要
void applyLocalizedPattern(String pattern)
将给定的模式应用于此 Format 对象。
void applyPattern(String pattern)
将给定的模式应用于此 Format 对象。
Object clone()
标准重写；没有语义上的变化。
boolean equals(Object obj)
重写 equals
StringBuffer format(double number, StringBuffer result, FieldPosition fieldPosition)
格式化一个 double 值，以生成一个字符串。
StringBuffer format(long number, StringBuffer result, FieldPosition fieldPosition)
格式化一个 long 值，以生成一个字符串。
StringBuffer format(Object number, StringBuffer toAppendTo, FieldPosition pos)
格式化一个数，并将所得文本追加到给定的字符串缓冲区。
AttributedCharacterIterator formatToCharacterIterator(Object obj)
格式化一个 Object，以生成一个 AttributedCharacterIterator。
Currency getCurrency()
获取格式化货币值时，此十进制格式使用的货币。
DecimalFormatSymbols getDecimalFormatSymbols()
返回小数格式符号的一个副本，通常程序员或用户不改变此副本。
int getGroupingSize()
返回分组大小。
int getMaximumFractionDigits()
获取某个数的小数部分中所允许的最大数字位数。
int getMaximumIntegerDigits()
获取某个数的整数部分中所允许的最大数字位数。
int getMinimumFractionDigits()
获取某个数的小数部分中所允许的最小数字位数。
int getMinimumIntegerDigits()
获取某个数的整数部分中所允许的最小数字位数。
int getMultiplier()
获取百分数、千分数和类似格式中使用的乘数。
String getNegativePrefix()
获取负数前缀。
String getNegativeSuffix()
获取负数后缀。
String getPositivePrefix()
获取正数前缀。
String getPositiveSuffix()
获取正数后缀。
RoundingMode getRoundingMode()
获取在此 DecimalFormat 中使用的 RoundingMode。
int hashCode()
重写 hashCode
boolean isDecimalSeparatorAlwaysShown()
允许获取整数中小数分隔符的行为。
boolean isParseBigDecimal()
返回 parse(java.lang.String, java.text.ParsePosition) 方法是否返回 BigDecimal。
Number parse(String text, ParsePosition pos)
解析字符串中的文本，以生成一个 Number。
void setCurrency(Currency currency)
设置格式化货币值时，此数字格式使用的货币。
void setDecimalFormatSymbols(DecimalFormatSymbols newSymbols)
设置小数格式符号，通常程序员或用户不改变此符号。
void setDecimalSeparatorAlwaysShown(boolean newValue)
允许设置整数中小数分隔符的行为。
void setGroupingSize(int newValue)
设置分组大小。
void setMaximumFractionDigits(int newValue)
设置某个数的小数部分中所允许的最大数字位数。
void setMaximumIntegerDigits(int newValue)
设置某个数字的整数部分中所允许的最大数字位数。
void setMinimumFractionDigits(int newValue)
设置某个数的小数部分中所允许的最小数字位数。
void setMinimumIntegerDigits(int newValue)
设置某个数字的整数部分中所允许的最小数字位数。
void setMultiplier(int newValue)
设置百分数、千分数和类似格式中使用的乘数。
void setNegativePrefix(String newValue)
设置负数前缀。
void setNegativeSuffix(String newValue)
设置负数后缀。
void setParseBigDecimal(boolean newValue)
设置 parse(java.lang.String, java.text.ParsePosition) 方法是否返回 BigDecimal。
void setPositivePrefix(String newValue)
设置正数前缀。
void setPositiveSuffix(String newValue)
设置正数后缀。
void setRoundingMode(RoundingMode roundingMode)
设置在此 DecimalFormat 中使用的 RoundingMode。
String toLocalizedPattern()
合成一个表示此 Format 对象当前状态的、已本地化的模式字符串。
String toPattern()
合成一个表示此 Format 对象当前状态的模式字符串。

从类 java.text.NumberFormat 继承的方法
format, format, getAvailableLocales, getCurrencyInstance, getCurrencyInstance, getInstance, getInstance, getIntegerInstance, getIntegerInstance, getNumberInstance, getNumberInstance, getPercentInstance, getPercentInstance, isGroupingUsed, isParseIntegerOnly, parse, parseObject, setGroupingUsed, setParseIntegerOnly

从类 java.text.Format 继承的方法
format, parseObject

从类 java.lang.Object 继承的方法
finalize, getClass, notify, notifyAll, toString, wait, wait, wait

构造方法详细信息
DecimalFormat

public DecimalFormat()
使用默认模式和默认语言环境的符号创建一个 DecimalFormat。当国际化不是主要的考虑方面时，这是获取 DecimalFormat 的便捷方式。
要为给定的语言环境获取标准的格式，请对 NumberFormat 使用工厂方法，如 getNumberInstance。这些工厂方法将为给定的语言环境返回最适合的 NumberFormat 子类。

另请参见：
NumberFormat.getInstance(), NumberFormat.getNumberInstance(), NumberFormat.getCurrencyInstance(), NumberFormat.getPercentInstance()
DecimalFormat

public DecimalFormat(String pattern)
使用给定的模式和默认语言环境的符号创建一个 DecimalFormat。当国际化不是主要的考虑方面时，这是获取 DecimalFormat 的便捷方式。
要为给定的语言环境获取标准的格式，请对 NumberFormat 使用工厂方法，如 getNumberInstance。这些工厂方法将为给定的语言环境返回最适合的 NumberFormat 子类。

参数：
pattern - 一个非本地化的模式字符串。
抛出：
NullPointerException - 如果 pattern 为 null
IllegalArgumentException - 如果给定的 pattern 无效。
另请参见：
NumberFormat.getInstance(), NumberFormat.getNumberInstance(), NumberFormat.getCurrencyInstance(), NumberFormat.getPercentInstance()
DecimalFormat

public DecimalFormat(String pattern,
DecimalFormatSymbols symbols)
使用给定的模式和符号创建一个 DecimalFormat。需要完全自定义格式化的行为时使用此构造方法。
要为给定的语言环境获取标准的格式，请对 NumberFormat 使用工厂方法，如 getInstance 或 getCurrencyInstance。如果只需为标准格式进行微小的调整，则可修改 NumberFormat 工厂方法所返回的格式。

参数：
pattern - 一个非本地化的模式字符串。
symbols - 要使用的符号集
抛出：
NullPointerException - 如果任意给定的参数为 null
IllegalArgumentException - 如果给定的 pattern 无效
另请参见：
NumberFormat.getInstance(), NumberFormat.getNumberInstance(), NumberFormat.getCurrencyInstance(), NumberFormat.getPercentInstance(), DecimalFormatSymbols
方法详细信息
format

public final StringBuffer format(Object number,
StringBuffer toAppendTo,
FieldPosition pos)
格式化一个数，并将所得文本追加到给定的字符串缓冲区。该数可以是 Number 的任意子类。
此实现使用所允许的最大精度。

覆盖：
类 NumberFormat 中的 format
参数：
number - 要格式化的数
toAppendTo - 将格式化的文本所要追加到的 StringBuffer
pos - 在输入上：如果需要，是一个对齐字段。在输出上：对齐字段的偏移量。
返回：
以 toAppendTo 形式传入的值
抛出：
IllegalArgumentException - 如果 number 为 null 或不是 Number 的一个实例。
NullPointerException - 如果 toAppendTo 或 pos 为 null
ArithmeticException - 如果需要使用设置为 RoundingMode.UNNECESSARY 的舍入模式进行舍入
另请参见：
FieldPosition
format

public StringBuffer format(double number,
StringBuffer result,
FieldPosition fieldPosition)
格式化一个 double 值，以生成一个字符串。
指定者：
类 NumberFormat 中的 format
参数：
number - 要格式化的 double 值
result - 将文本追加到的地方
fieldPosition - 在输入上：如果需要，是一个对齐字段。在输出上：对齐字段的偏移量。
返回：
已格式化的数字字符串
抛出：
ArithmeticException - 如果需要使用设置为 RoundingMode.UNNECESSARY 的舍入模式进行舍入
另请参见：
FieldPosition
format

public StringBuffer format(long number,
StringBuffer result,
FieldPosition fieldPosition)
格式化一个 long 值，以生成一个字符串。
指定者：
类 NumberFormat 中的 format
参数：
number - 要格式化的 long 值
result - 将文本追加到的地方
fieldPosition - 在输入上：如果需要，是一个对齐字段。在输出上：对齐字段的偏移量。
返回：
已格式化的数字字符串
抛出：
ArithmeticException - 如果需要使用设置为 RoundingMode.UNNECESSARY 的舍入模式进行舍入
另请参见：
FieldPosition
formatToCharacterIterator

public AttributedCharacterIterator formatToCharacterIterator(Object obj)
格式化一个 Object，以生成一个 AttributedCharacterIterator。可以使用返回的 AttributedCharacterIterator 来生成所得 String，并确定有关所得 String 的信息。
AttributedCharacterIterator 的每个属性键都是 NumberFormat.Field 类型的，属性值与属性键相同。

覆盖：
类 Format 中的 formatToCharacterIterator
参数：
obj - 要格式化的对象
返回：
描述格式化值的 AttributedCharacterIterator。
抛出：
NullPointerException - 如果 obj 为 null。
IllegalArgumentException - Format 无法格式化给定的对象时。
ArithmeticException - 如果需要使用设置为 RoundingMode.UNNECESSARY 的舍入模式进行舍入
从以下版本开始：
1.4
parse

public Number parse(String text,
ParsePosition pos)
解析字符串中的文本，以生成一个 Number。
该方法试图解析从 pos 所给定的索引处开始的文本。如果解析成功，则将 pos 的索引更新为所用最后一个字符后面的索引（不一定解析直到字符串末尾的所有字符），并返回解析后的数。可以使用更新后的 pos 指示下一次调用此方法的开始点。如果发生错误，则不更改 pos 的索引，并将 pos 的错误索引设置为发生错误处的字符索引，并且返回 null。

返回的子类取决于 isParseBigDecimal() 的值以及所解析的字符串。

如果 isParseBigDecimal() 为 false（默认值），则以 Long 对象返回多数整数值，而不管其写入方式如何：”17” 和 “17.000” 都解析成 Long(17)。不符合 Long 的值则以 Double 的形式返回。这包括有小数部分的值、无穷大的值、NaN 和值 -0.0。DecimalFormat 不 根据源字符串中是否有小数分隔符来决定返回 Double 还是 Long 值。这样做会无法准确地解析导致某个 double 尾数（如 “-9,223,372,036,854,775,808.00”）溢出的整数。
调用者可能使用 Number 的方法 doubleValue、longValue 等来获取所需类型的数值。

如果 isParseBigDecimal() 为 true，则以 BigDecimal 对象的形式返回值。这些值是由 BigDecimal.BigDecimal(String) 以和语言环境无关的格式为相应字符串所构造的那些值。特殊的情况是正负无穷大和 NaN 值，它们以 Double 实例的形式返回，其中保存了相应的 Double 常量值。
DecimalFormat 解析所有由 Character.digit() 所定义的、表示小数数字的 Unicode 字符。另外，DecimalFormat 也将 DecimalFormatSymbols 对象中所定义的、从已本地化的阿拉伯数字 0 开始的 10 个连续字符识别为阿拉伯数字。

指定者：
类 NumberFormat 中的 parse
参数：
text - 要解析的字符串
pos - 具有索引和上述错误索引信息的 ParsePosition 对象。
返回：
解析得到的值，如果解析失败，则为 null
抛出：
NullPointerException - 如果 text 或 pos 为 null。
另请参见：
NumberFormat.isParseIntegerOnly(), Format.parseObject(java.lang.String, java.text.ParsePosition)
getDecimalFormatSymbols

public DecimalFormatSymbols getDecimalFormatSymbols()
返回小数格式符号的一个副本，通常程序员或用户不改变此副本。
返回：
所需的 DecimalFormatSymbols 的一个副本
另请参见：
DecimalFormatSymbols
setDecimalFormatSymbols

public void setDecimalFormatSymbols(DecimalFormatSymbols newSymbols)
设置小数格式符号，通常程序员或用户不改变此符号。
参数：
newSymbols - 所需的 DecimalFormatSymbols
另请参见：
DecimalFormatSymbols
getPositivePrefix

public String getPositivePrefix()
获取正数前缀。
示例：+123、$123、sFr123

setPositivePrefix

public void setPositivePrefix(String newValue)
设置正数前缀。
示例：+123、$123、sFr123

getNegativePrefix

public String getNegativePrefix()
获取负数前缀。
示例：-123、($123)（带有负数后缀）、sFr-123

setNegativePrefix

public void setNegativePrefix(String newValue)
设置负数前缀。
示例：-123、($123)（带有负数后缀）、sFr-123

getPositiveSuffix

public String getPositiveSuffix()
获取正数后缀。
示例： 123%

setPositiveSuffix

public void setPositiveSuffix(String newValue)
设置正数后缀。
示例：123%

getNegativeSuffix

public String getNegativeSuffix()
获取负数后缀。
示例：-123%、($123)（带有正数后缀）

setNegativeSuffix

public void setNegativeSuffix(String newValue)
设置负数后缀。
示例： 123%

getMultiplier

public int getMultiplier()
获取百分数、千分数和类似格式中使用的乘数。
另请参见：
setMultiplier(int)
setMultiplier

public void setMultiplier(int newValue)
设置百分数、千分数和类似格式中使用的乘数。对于百分数格式，将该乘数设置为 100 并将后缀设置为 ‘%’（对于阿拉伯语，请使用阿拉伯语的百分数符号）。对于千分数格式，将该乘数设置为 1000 并将后缀设置为 ‘\u2030’。
示例：使用乘数 100 时，1.23 被格式化为 “123”，”123” 则被解析为 1.23。

另请参见：
getMultiplier()
getGroupingSize

public int getGroupingSize()
返回分组大小。分组大小是数的整数部分中分组分隔符之间的数字位数。例如在数 “123,456.78” 中，分组大小是 3。
另请参见：
setGroupingSize(int), NumberFormat.isGroupingUsed(), DecimalFormatSymbols.getGroupingSeparator()
setGroupingSize

public void setGroupingSize(int newValue)
设置分组大小。分组大小是数的整数部分中分组分隔符之间的数字位数。例如在数 “123,456.78” 中，分组大小是 3。
传入的值被转换为 一个字节，这可能导致信息丢失。
另请参见：
getGroupingSize(), NumberFormat.setGroupingUsed(boolean), DecimalFormatSymbols.setGroupingSeparator(char)
isDecimalSeparatorAlwaysShown

public boolean isDecimalSeparatorAlwaysShown()
允许获取整数中小数分隔符的行为。（有小数时始终显示小数分隔符。）
示例：小数 ON： 12345 -> 12345.; OFF: 12345 -> 12345

setDecimalSeparatorAlwaysShown

public void setDecimalSeparatorAlwaysShown(boolean newValue)
允许设置整数中小数分隔符的行为。（有小数时始终显示小数分隔符。）
示例：小数 ON： 12345 -> 12345.; OFF: 12345 -> 12345

isParseBigDecimal

public boolean isParseBigDecimal()
返回 parse(java.lang.String, java.text.ParsePosition) 方法是否返回 BigDecimal。默认值为 false。
从以下版本开始：
1.5
另请参见：
setParseBigDecimal(boolean)
setParseBigDecimal

public void setParseBigDecimal(boolean newValue)
设置 parse(java.lang.String, java.text.ParsePosition) 方法是否返回 BigDecimal。
从以下版本开始：
1.5
另请参见：
isParseBigDecimal()
clone

public Object clone()
标准重写；没有语义上的变化。
覆盖：
类 NumberFormat 中的 clone
返回：
此实例的一个副本。
另请参见：
Cloneable
equals

public boolean equals(Object obj)
重写 equals
覆盖：
类 NumberFormat 中的 equals
参数：
obj - 要与之比较的引用对象。
返回：
如果此对象与 obj 参数相同，则返回 true；否则返回 false。
另请参见：
Object.hashCode(), Hashtable
hashCode

public int hashCode()
重写 hashCode
覆盖：
类 NumberFormat 中的 hashCode
返回：
此对象的一个哈希码值。
另请参见：
Object.equals(java.lang.Object), Hashtable
toPattern

public String toPattern()
合成一个表示此 Format 对象当前状态的模式字符串。
另请参见：
applyPattern(java.lang.String)
toLocalizedPattern

public String toLocalizedPattern()
合成一个表示此 Format 对象当前状态的、已本地化的模式字符串。
另请参见：
applyPattern(java.lang.String)
applyPattern

public void applyPattern(String pattern)
将给定的模式应用于此 Format 对象。模式是各种格式化属性的简写规范。也可以通过各种设置方法来单独改变这些属性。
对此例程所设置的整数位数没有限制，因为这通常是终端用户的需要；如果想设置某个实际值，请使用 setMaximumInteger。对于负数，可使用由分号分隔的第二个模式。

示例 “#,#00.0#” -> 1,234.56

这意味着最少 2 个整数位数、1 个小数位数，以及最多 2 个小数位数。

示例：”#,#00.0#;(#,#00.0#)”，括号中的内容用于负数。

在负数模式中，忽略最小和最大计数；在正数模式中假定要设置这些计数。

抛出：
NullPointerException - 如果 pattern 为 null
IllegalArgumentException - 如果给定的 pattern 无效。
applyLocalizedPattern

public void applyLocalizedPattern(String pattern)
将给定的模式应用于此 Format 对象。假定该 pattern 以本地化表示法来表示。模式是各种格式化属性的简写规范。也可以通过各种设置方法来单独改变这些属性。
对此例程所设置的整数位数没有限制，因为这通常是终端用户的需要；如果想设置某个实际值，请使用 setMaximumInteger。对于负数，可使用由分号分隔的第二个模式

示例 “#,#00.0#” -> 1,234.56

这意味着最少 2 个整数位数、1 个小数位数，以及最多 2 个小数位数。

示例：”#,#00.0#;(#,#00.0#)”，括号中的内容用于负数。

在负数模式中，忽略最小和最大计数；在正数模式中假定要设置这些计数。

抛出：
NullPointerException - 如果 pattern 为 null
IllegalArgumentException - 如果给定的 pattern 无效。
setMaximumIntegerDigits

public void setMaximumIntegerDigits(int newValue)
设置某个数字的整数部分中所允许的最大数字位数。如需格式化除 BigInteger 和 BigDecimal 对象之外的数字，则使用 newValue 的低位部分和 309。用 0 替换负数输入值。
覆盖：
类 NumberFormat 中的 setMaximumIntegerDigits
参数：
newValue - 要显示的最大整数位数；如果小于 0，则使用 0。具体子类可以为此值强加一个上限，以适合于被格式化的数值类型。
另请参见：
NumberFormat.setMaximumIntegerDigits(int)
setMinimumIntegerDigits

public void setMinimumIntegerDigits(int newValue)
设置某个数字的整数部分中所允许的最小数字位数。如需格式化除 BigInteger 和 BigDecimal 对象之外的数字，则使用 newValue 的低位部分和 309。用 0 替换负数输入值。
覆盖：
类 NumberFormat 中的 setMinimumIntegerDigits
参数：
newValue - 要显示的整数的最小位数；如果小于 0，则使用 0。具体子类可以为此值强加一个上限，以适合于被格式化的数值类型。
另请参见：
NumberFormat.setMinimumIntegerDigits(int)
setMaximumFractionDigits

public void setMaximumFractionDigits(int newValue)
设置某个数的小数部分中所允许的最大数字位数。如需格式化除 BigInteger 和 BigDecimal 对象之外的数字，则使用 newValue 的低位部分和 340。用 0 替换负数输入值。
覆盖：
类 NumberFormat 中的 setMaximumFractionDigits
参数：
newValue - 要显示的小数的最大位数；如果小于 0，则使用 0。具体子类可以为此值强加一个上限，以适合于被格式化的数值类型。
另请参见：
NumberFormat.setMaximumFractionDigits(int)
setMinimumFractionDigits

public void setMinimumFractionDigits(int newValue)
设置某个数的小数部分中所允许的最小数字位数。如需格式化除 BigInteger 和 BigDecimal 对象之外的数字，则使用 newValue 的低位部分和 340。用 0 替换负数输入值。
覆盖：
类 NumberFormat 中的 setMinimumFractionDigits
参数：
newValue - 要显示的小数的最小位数；如果小于 0，则使用 0。具体子类可以为此值强加一个上限，以适合于被格式化的数值类型。
另请参见：
NumberFormat.setMinimumFractionDigits(int)
getMaximumIntegerDigits

public int getMaximumIntegerDigits()
获取某个数的整数部分中所允许的最大数字位数。如需格式化除 BigInteger 和 BigDecimal 对象之外的数字，则使用返回值的低位部分和 309。
覆盖：
类 NumberFormat 中的 getMaximumIntegerDigits
另请参见：
setMaximumIntegerDigits(int)
getMinimumIntegerDigits

public int getMinimumIntegerDigits()
获取某个数的整数部分中所允许的最小数字位数。如需格式化除 BigInteger 和 BigDecimal 对象之外的数字，则使用返回值的低位部分和 309。
覆盖：
类 NumberFormat 中的 getMinimumIntegerDigits
另请参见：
setMinimumIntegerDigits(int)
getMaximumFractionDigits

public int getMaximumFractionDigits()
获取某个数的小数部分中所允许的最大数字位数。如需格式化除 BigInteger 和 BigDecimal 对象之外的数，则使用返回值的低位部分和 340。
覆盖：
类 NumberFormat 中的 getMaximumFractionDigits
另请参见：
setMaximumFractionDigits(int)
getMinimumFractionDigits

public int getMinimumFractionDigits()
获取某个数的小数部分中所允许的最小数字位数。如需格式化除 BigInteger 和 BigDecimal 对象之外的数，则使用返回值的低位部分和 340。
覆盖：
类 NumberFormat 中的 getMinimumFractionDigits
另请参见：
setMinimumFractionDigits(int)
getCurrency

public Currency getCurrency()
获取格式化货币值时，此十进制格式使用的货币。通过在此数字格式的符号上调用 DecimalFormatSymbols.getCurrency 来获取该货币。
覆盖：
类 NumberFormat 中的 getCurrency
返回：
此十进制格式使用的货币，或者为 null
从以下版本开始：
1.4
setCurrency

public void setCurrency(Currency currency)
设置格式化货币值时，此数字格式使用的货币。这不会更新该数字格式使用的最小和最大小数位数。通过在此数字格式的符号上调用 DecimalFormatSymbols.setCurrency 来设置该货币。
覆盖：
类 NumberFormat 中的 setCurrency
参数：
currency - 此十进制格式要使用的新货币
抛出：
NullPointerException - 如果 currency 为 null
从以下版本开始：
1.4
getRoundingMode

public RoundingMode getRoundingMode()
获取在此 DecimalFormat 中使用的 RoundingMode。
覆盖：
类 NumberFormat 中的 getRoundingMode
返回：
用于此 DecimalFormat 的 RoundingMode。
从以下版本开始：
1.6
另请参见：
setRoundingMode(RoundingMode)
setRoundingMode

public void setRoundingMode(RoundingMode roundingMode)
设置在此 DecimalFormat 中使用的 RoundingMode。
覆盖：
类 NumberFormat 中的 setRoundingMode
参数：
roundingMode - 要使用的 RoundingMode
抛出：
NullPointerException - 如果 roundingMode 为 null。
从以下版本开始：
1.6
另请参见：
getRoundingMode()