public class DecimalFormat extends NumberFormat
DecimalFormat is a concrete subclass of NumberFormat
for formatting decimal numbers. This class allows for a variety
of parameters, and localization to Western, Arabic, or Indic numbers.
Normally, you get the proper NumberFormat for a specific
locale (including the default locale) using one of NumberFormat's
factory methods such as getInstance. You may then modify it
from there (after testing to make sure it is a DecimalFormat,
of course!)
Either the prefixes or the suffixes must be different for the parse to distinguish positive from negative. Parsing will be unreliable if the digits, thousands or decimal separators are the same, or if any of them occur in the prefixes or suffixes.
Special cases:
NaN is formatted as a single character, typically
\\uFFFD.
+/-Infinity is formatted as a single character, typically \\u221E,
plus the positive and negative pre/suffixes.
Note: this class is designed for common users; for very
large or small numbers, use a format that can express exponential values.
Example:
// normally we would have a GUI with a menu for this
Locale[] locales = NumberFormat.getAvailableLocales();
double myNumber = -1234.56;
NumberFormat form;
// just for fun, we print out a number with the locale number, currency
// and percent format for each locale we can.
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
continue;
}
System.out.print(locales[i].getDisplayName());
switch (j) {
default:
form = NumberFormat.getInstance(locales[i]); break;
case 1:
form = NumberFormat.getCurrencyInstance(locales[i]); break;
case 0:
form = NumberFormat.getPercentInstance(locales[i]); break;
}
try {
System.out.print(": " + ((DecimalFormat)form).toPattern()
+ " -> " + form.format(myNumber));
} catch (IllegalArgumentException iae) { }
try {
System.out.println(" -> " + form.parse(form.format(myNumber)));
} catch (ParseException pe) { }
}
}
The following shows the structure of the pattern.
pattern := subpattern{;subpattern}
subpattern := {prefix}integer{.fraction}{suffix}
prefix := '\\u0000'..'\\uFFFD' - specialCharacters
suffix := '\\u0000'..'\\uFFFD' - specialCharacters
integer := '#'* '0'* '0'
fraction := '0'* '#'*
Notation:
X* 0 or more instances of X
(X | Y) either X or Y.
X..Y any character from X up to Y, 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. (In both cases, ',' can occur
inside the integer portion--it is just too messy to indicate in BNF.)
Here are the special characters used in the parts of the subpattern, with notes on their usage.
Symbol Meaning
0 a digit
# a digit, zero shows as absent
. placeholder for decimal separator
, placeholder for grouping separator.
; separates formats.
- default negative prefix.
% multiply by 100 and show as percentage
‰ multiply by 1000 and show as per mille
¤ 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.
X any other characters can be used in the prefix or suffix
' used to quote special characters in a prefix or suffix.
Notes
If there is no explicit negative subpattern, - is prefixed to the positive form. That is, "0.00" alone is equivalent to "0.00;-0.00".
Illegal patterns, such as "#.#.#" or mixing '_' and '*' in the
same pattern, will cause an IllegalArgumentException to be
thrown. From the message of IllegalArgumentException, you can
find the place in the string where the error occurred.
The grouping separator is commonly used for thousands, but in some countries for ten-thousands. The interval is a constant number of digits between the grouping characters, such as 100,000,000 or 1,0000,0000. If you supply a pattern with multiple grouping characters, the interval between the last one and the end of the integer is the one that is used. So "#,##,###,####" == "######,####" == "##,####,####".
When calling DecimalFormat.parse(String, ParsePosition) and parsing fails, a null object will be returned. The unchanged parse position also reflects that an error has occurred during parsing. When calling the convenient method DecimalFormat.parse(String) and parsing fails, a ParseException will be thrown.
This class only handles localized digits where the 10 digits are contiguous in Unicode, from 0 to 9. Other digits sets (such as superscripts) would need a different subclass.
Format,
NumberFormatFRACTION_FIELD, INTEGER_FIELD| Constructor and Description |
|---|
DecimalFormat()
Create a DecimalFormat using the default pattern and symbols
for the default locale.
|
DecimalFormat(String pattern)
Create a DecimalFormat from the given pattern and the symbols
for the default locale.
|
DecimalFormat(String pattern,
DecimalFormatSymbols symbols)
Create a DecimalFormat from the given pattern and symbols.
|
| Modifier and Type | Method and Description |
|---|---|
void |
applyLocalizedPattern(String pattern)
Apply the given pattern to this Format object.
|
void |
applyPattern(String pattern)
Apply the given pattern to this Format object.
|
Object |
clone()
Standard override; no change in semantics.
|
boolean |
equals(Object obj)
Overrides equals.
|
StringBuffer |
format(double number,
StringBuffer result,
FieldPosition fieldPosition)
Specialization of format.
|
StringBuffer |
format(long number,
StringBuffer result,
FieldPosition fieldPosition)
Specialization of format.
|
DecimalFormatSymbols |
getDecimalFormatSymbols()
Returns the decimal format symbols, which is generally not changed
by the programmer or user.
|
int |
getGroupingSize()
Return the grouping size.
|
int |
getMultiplier()
Get the multiplier for use in percent, permill, etc.
|
String |
getNegativePrefix()
Get the negative prefix.
|
String |
getNegativeSuffix()
Get the negative suffix.
|
String |
getPositivePrefix()
Get the positive prefix.
|
String |
getPositiveSuffix()
Get the positive suffix.
|
int |
hashCode()
Overrides hashCode.
|
boolean |
isDecimalSeparatorAlwaysShown()
Allows you to get the behavior of the decimal separator with integers.
|
Number |
parse(String text,
ParsePosition parsePosition)
Returns a Long if possible (e.g.
|
void |
setDecimalFormatSymbols(DecimalFormatSymbols newSymbols)
Sets the decimal format symbols, which is generally not changed
by the programmer or user.
|
void |
setDecimalSeparatorAlwaysShown(boolean newValue)
Allows you to set the behavior of the decimal separator with integers.
|
void |
setGroupingSize(int newValue)
Set the grouping size.
|
void |
setMultiplier(int newValue)
Set the multiplier for use in percent, permill, etc.
|
void |
setNegativePrefix(String newValue)
Set the negative prefix.
|
void |
setNegativeSuffix(String newValue)
Set the positive suffix.
|
void |
setPositivePrefix(String newValue)
Set the positive prefix.
|
void |
setPositiveSuffix(String newValue)
Set the positive suffix.
|
String |
toLocalizedPattern()
Synthesizes a localized pattern string that represents the current
state of this Format object.
|
String |
toPattern()
Synthesizes a pattern string that represents the current state
of this Format object.
|
format, format, format, getAvailableLocales, getCurrencyInstance, getCurrencyInstance, getInstance, getInstance, getMaximumFractionDigits, getMaximumIntegerDigits, getMinimumFractionDigits, getMinimumIntegerDigits, getNumberInstance, getNumberInstance, getPercentInstance, getPercentInstance, isGroupingUsed, isParseIntegerOnly, parse, parseObject, setGroupingUsed, setMaximumFractionDigits, setMaximumIntegerDigits, setMinimumFractionDigits, setMinimumIntegerDigits, setParseIntegerOnlyformat, parseObjectpublic DecimalFormat()
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.
public DecimalFormat(String pattern)
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.
pattern - A non-localized pattern string.IllegalArgumentException - if the given pattern is invalid.NumberFormat.getInstance(),
NumberFormat.getNumberInstance(),
NumberFormat.getCurrencyInstance(),
NumberFormat.getPercentInstance()public DecimalFormat(String pattern, DecimalFormatSymbols symbols)
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.
pattern - a non-localized pattern stringsymbols - the set of symbols to be usedIllegalArgumentException - if the given pattern is invalidNumberFormat.getInstance(),
NumberFormat.getNumberInstance(),
NumberFormat.getCurrencyInstance(),
NumberFormat.getPercentInstance(),
DecimalFormatSymbolspublic StringBuffer format(double number, StringBuffer result, FieldPosition fieldPosition)
NumberFormatformat in class NumberFormatnumber - ?result - ?fieldPosition - ?Format.format(java.lang.Object)public StringBuffer format(long number, StringBuffer result, FieldPosition fieldPosition)
NumberFormatformat in class NumberFormatnumber - ?result - ?fieldPosition - ?Format.format(java.lang.Object)public Number parse(String text, ParsePosition parsePosition)
NumberFormatparse in class NumberFormattext - ?parsePosition - ?NumberFormat.isParseIntegerOnly(),
Format.parseObject(java.lang.String, java.text.ParsePosition)public DecimalFormatSymbols getDecimalFormatSymbols()
DecimalFormatSymbolspublic void setDecimalFormatSymbols(DecimalFormatSymbols newSymbols)
newSymbols - desired DecimalFormatSymbolsDecimalFormatSymbolspublic String getPositivePrefix()
Examples: +123, $123, sFr123
public void setPositivePrefix(String newValue)
Examples: +123, $123, sFr123
newValue - ?public String getNegativePrefix()
Examples: -123, ($123) (with negative suffix), sFr-123
public void setNegativePrefix(String newValue)
Examples: -123, ($123) (with negative suffix), sFr-123
newValue - ?public String getPositiveSuffix()
Example: 123%
public void setPositiveSuffix(String newValue)
Example: 123%
newValue - ?public String getNegativeSuffix()
Examples: -123%, ($123) (with positive suffixes)
public void setNegativeSuffix(String newValue)
Examples: 123%
newValue - ?public int getMultiplier()
Examples: with 100, 1.23 -> "123", and "123" -> 1.23
public void setMultiplier(int newValue)
Examples: with 100, 1.23 -> "123", and "123" -> 1.23
newValue - ?public int getGroupingSize()
setGroupingSize(int),
NumberFormat.isGroupingUsed(),
DecimalFormatSymbols.getGroupingSeparator()public void setGroupingSize(int newValue)
newValue - ?getGroupingSize(),
NumberFormat.setGroupingUsed(boolean),
DecimalFormatSymbols.setGroupingSeparator(char)public boolean isDecimalSeparatorAlwaysShown()
Example: Decimal ON: 12345 -> 12345.; OFF: 12345 -> 12345
public void setDecimalSeparatorAlwaysShown(boolean newValue)
Example: Decimal ON: 12345 -> 12345.; OFF: 12345 -> 12345
newValue - ?public Object clone()
clone in class NumberFormatCloneablepublic boolean equals(Object obj)
equals in class NumberFormatobj - the reference object with which to compare.Boolean.hashCode(),
Hashtablepublic int hashCode()
hashCode in class NumberFormatObject.equals(java.lang.Object),
Hashtablepublic String toPattern()
applyPattern(java.lang.String)public String toLocalizedPattern()
applyPattern(java.lang.String)public void applyPattern(String pattern)
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 parantheses.
In negative patterns, the minimum and maximum counts are ignored; these are presumed to be set in the positive pattern.
pattern - ?public void applyLocalizedPattern(String pattern)
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 parantheses.
In negative patterns, the minimum and maximum counts are ignored; these are presumed to be set in the positive pattern.
pattern - ?