DecimalFormat which uses the default
* pattern and symbols.
*/
public DecimalFormat ()
{
this ("#,##0.###");
}
/**
* Constructs a DecimalFormat which uses the given
* pattern and the default symbols for formatting and parsing.
*
* @param pattern the non-localized pattern to use.
* @throws NullPointerException if any argument is null.
* @throws IllegalArgumentException if the pattern is invalid.
*/
public DecimalFormat (String pattern)
{
this (pattern, new DecimalFormatSymbols ());
}
/**
* Constructs a DecimalFormat using the given pattern
* and formatting symbols. This construction method is used to give
* complete control over the formatting process.
*
* @param pattern the non-localized pattern to use.
* @param symbols the set of symbols used for parsing and formatting.
* @throws NullPointerException if any argument is null.
* @throws IllegalArgumentException if the pattern is invalid.
*/
public DecimalFormat (String pattern, DecimalFormatSymbols symbols)
{
if (symbols == null)
{
throw new NullPointerException("Supplied set of symbols is null.");
}
this.symbols = symbols;
applyPattern(pattern);
}
private boolean equals(String s1, String s2)
{
if (s1 == null || s2 == null)
return s1 == s2;
return s1.equals(s2);
}
public boolean equals (Object obj)
{
if (! (obj instanceof DecimalFormat))
return false;
DecimalFormat dup = (DecimalFormat) obj;
return (decimalSeparatorAlwaysShown == dup.decimalSeparatorAlwaysShown
&& groupingSize == dup.groupingSize
&& minExponentDigits == dup.minExponentDigits
&& multiplier == dup.multiplier
&& equals(negativePrefix, dup.negativePrefix)
&& equals(negativeSuffix, dup.negativeSuffix)
&& equals(positivePrefix, dup.positivePrefix)
&& equals(positiveSuffix, dup.positiveSuffix)
&& symbols.equals(dup.symbols)
&& useExponentialNotation == dup.useExponentialNotation);
}
private void formatInternal (double number, FormatBuffer dest,
FieldPosition fieldPos)
{
// A very special case.
if (Double.isNaN(number))
{
dest.append(symbols.getNaN());
if (fieldPos != null &&
(fieldPos.getField() == INTEGER_FIELD ||
fieldPos.getFieldAttribute() == NumberFormat.Field.INTEGER))
{
int index = dest.length();
fieldPos.setBeginIndex(index - symbols.getNaN().length());
fieldPos.setEndIndex(index);
}
return;
}
boolean is_neg = number < 0;
if (is_neg)
{
if (negativePrefix != null)
{
dest.append(substituteCurrency(negativePrefix, number),
negativePrefixRanges, negativePrefixAttrs);
}
else
{
dest.append(symbols.getMinusSign(), NumberFormat.Field.SIGN);
dest.append(substituteCurrency(positivePrefix, number),
positivePrefixRanges, positivePrefixAttrs);
}
number = - number;
}
else
{
dest.append(substituteCurrency(positivePrefix, number),
positivePrefixRanges, positivePrefixAttrs);
}
int integerBeginIndex = dest.length();
int integerEndIndex = 0;
int zeroStart = symbols.getZeroDigit() - '0';
if (Double.isInfinite (number))
{
dest.append(symbols.getInfinity());
integerEndIndex = dest.length();
}
else
{
number *= multiplier;
// Compute exponent.
long exponent = 0;
double baseNumber;
if (useExponentialNotation)
{
exponent = (long) Math.floor (Math.log(number) / Math.log(10));
exponent = exponent - (exponent % exponentRound);
if (minimumIntegerDigits > 0)
exponent -= minimumIntegerDigits - 1;
baseNumber = (number / Math.pow(10.0, exponent));
}
else
baseNumber = number;
// Round to the correct number of digits.
baseNumber += 5 * Math.pow(10.0, - maximumFractionDigits - 1);
int index = dest.length();
//double intPart = Math.floor(baseNumber);
String intPart = Long.toString((long)Math.floor(baseNumber));
int count, groupPosition = intPart.length();
dest.setDefaultAttribute(NumberFormat.Field.INTEGER);
for (count = 0; count < minimumIntegerDigits-intPart.length(); count++)
dest.append(symbols.getZeroDigit());
for (count = 0;
count < maximumIntegerDigits && count < intPart.length();
count++)
{
int dig = intPart.charAt(count);
// Append group separator if required.
if (groupingUsed && count > 0 && groupingSize != 0 && groupPosition % groupingSize == 0)
{
dest.append(symbols.getGroupingSeparator(), NumberFormat.Field.GROUPING_SEPARATOR);
dest.setDefaultAttribute(NumberFormat.Field.INTEGER);
}
dest.append((char) (zeroStart + dig));
groupPosition--;
}
dest.setDefaultAttribute(null);
integerEndIndex = dest.length();
int decimal_index = integerEndIndex;
int consecutive_zeros = 0;
int total_digits = 0;
int localMaximumFractionDigits = maximumFractionDigits;
if (useExponentialNotation)
localMaximumFractionDigits += minimumIntegerDigits - count;
// Strip integer part from NUMBER.
double fracPart = baseNumber - Math.floor(baseNumber);
if ( ((fracPart != 0 || minimumFractionDigits > 0) && localMaximumFractionDigits > 0)
|| decimalSeparatorAlwaysShown)
{
dest.append (symbols.getDecimalSeparator(), NumberFormat.Field.DECIMAL_SEPARATOR);
}
int fraction_begin = dest.length();
dest.setDefaultAttribute(NumberFormat.Field.FRACTION);
for (count = 0;
count < localMaximumFractionDigits
&& (fracPart != 0 || count < minimumFractionDigits);
++count)
{
++total_digits;
fracPart *= 10;
long dig = (long) fracPart;
if (dig == 0)
++consecutive_zeros;
else
consecutive_zeros = 0;
dest.append((char) (symbols.getZeroDigit() + dig));
// Strip integer part from FRACPART.
fracPart = fracPart - Math.floor (fracPart);
}
// Strip extraneous trailing `0's. We can't always detect
// these in the loop.
int extra_zeros = Math.min (consecutive_zeros,
total_digits - minimumFractionDigits);
if (extra_zeros > 0)
{
dest.cutTail(extra_zeros);
total_digits -= extra_zeros;
if (total_digits == 0 && !decimalSeparatorAlwaysShown)
dest.cutTail(1);
}
if (fieldPos != null && fieldPos.getField() == FRACTION_FIELD)
{
fieldPos.setBeginIndex(fraction_begin);
fieldPos.setEndIndex(dest.length());
}
// Finally, print the exponent.
if (useExponentialNotation)
{
dest.append(symbols.getExponential(), NumberFormat.Field.EXPONENT_SYMBOL);
if (exponent < 0)
{
dest.append (symbols.getMinusSign (), NumberFormat.Field.EXPONENT_SIGN);
exponent = - exponent;
}
index = dest.length();
dest.setDefaultAttribute(NumberFormat.Field.EXPONENT);
String exponentString = Long.toString ((long) exponent);
for (count = 0; count < minExponentDigits-exponentString.length();
count++)
dest.append((char) symbols.getZeroDigit());
for (count = 0;
count < exponentString.length();
++count)
{
int dig = exponentString.charAt(count);
dest.append((char) (zeroStart + dig));
}
}
}
if (fieldPos != null &&
(fieldPos.getField() == INTEGER_FIELD ||
fieldPos.getFieldAttribute() == NumberFormat.Field.INTEGER))
{
fieldPos.setBeginIndex(integerBeginIndex);
fieldPos.setEndIndex(integerEndIndex);
}
if (is_neg && negativeSuffix != null)
{
dest.append(substituteCurrency(negativeSuffix, number),
negativeSuffixRanges, negativeSuffixAttrs);
}
else
{
dest.append(substituteCurrency(positiveSuffix, number),
positiveSuffixRanges, positiveSuffixAttrs);
}
}
public StringBuffer format (double number, StringBuffer dest,
FieldPosition fieldPos)
{
formatInternal (number, new StringFormatBuffer(dest), fieldPos);
return dest;
}
public AttributedCharacterIterator formatToCharacterIterator (Object value)
{
AttributedFormatBuffer sbuf = new AttributedFormatBuffer();
if (value instanceof Number)
formatInternal(((Number) value).doubleValue(), sbuf, null);
else
throw new IllegalArgumentException
("Cannot format given Object as a Number");
sbuf.sync();
return new FormatCharacterIterator(sbuf.getBuffer().toString(),
sbuf.getRanges(),
sbuf.getAttributes());
}
public StringBuffer format (long number, StringBuffer dest,
FieldPosition fieldPos)
{
// If using exponential notation, we just format as a double.
if (useExponentialNotation)
return format ((double) number, dest, fieldPos);
boolean is_neg = number < 0;
if (is_neg)
{
if (negativePrefix != null)
dest.append(substituteCurrency(negativePrefix, number));
else
{
dest.append(symbols.getMinusSign());
dest.append(substituteCurrency(positivePrefix, number));
}
number = - number;
}
else
dest.append(substituteCurrency(positivePrefix, number));
int integerBeginIndex = dest.length();
int index = dest.length();
int count = 0;
/* Handle percentages, etc. */
number *= multiplier;
while (count < maximumIntegerDigits
&& (number > 0 || count < minimumIntegerDigits))
{
long dig = number % 10;
number /= 10;
// NUMBER and DIG will be less than 0 if the original number
// was the most negative long.
if (dig < 0)
{
dig = - dig;
number = - number;
}
// Append group separator if required.
if (groupingUsed && count > 0 && groupingSize != 0 && count % groupingSize == 0)
dest.insert(index, symbols.getGroupingSeparator());
dest.insert(index, (char) (symbols.getZeroDigit() + dig));
++count;
}
if (fieldPos != null && fieldPos.getField() == INTEGER_FIELD)
{
fieldPos.setBeginIndex(integerBeginIndex);
fieldPos.setEndIndex(dest.length());
}
if (decimalSeparatorAlwaysShown || minimumFractionDigits > 0)
{
dest.append(symbols.getDecimalSeparator());
if (fieldPos != null && fieldPos.getField() == FRACTION_FIELD)
{
fieldPos.setBeginIndex(dest.length());
fieldPos.setEndIndex(dest.length() + minimumFractionDigits);
}
}
for (count = 0; count < minimumFractionDigits; ++count)
dest.append(symbols.getZeroDigit());
dest.append((is_neg && negativeSuffix != null)
? substituteCurrency(negativeSuffix, number)
: substituteCurrency(positiveSuffix, number));
return dest;
}
/**
* Returns the currency corresponding to the currency symbol stored
* in the instance of DecimalFormatSymbols used by this
* DecimalFormat.
*
* @return A new instance of Currency if
* the currency code matches a known one, null otherwise.
*/
public Currency getCurrency()
{
return symbols.getCurrency();
}
public DecimalFormatSymbols getDecimalFormatSymbols ()
{
return symbols;
}
public int getGroupingSize ()
{
return groupingSize;
}
public int getMultiplier ()
{
return multiplier;
}
public String getNegativePrefix ()
{
return negativePrefix;
}
public String getNegativeSuffix ()
{
return negativeSuffix;
}
public String getPositivePrefix ()
{
return positivePrefix;
}
public String getPositiveSuffix ()
{
return positiveSuffix;
}
public int hashCode ()
{
int hash = (negativeSuffix.hashCode() ^ negativePrefix.hashCode()
^positivePrefix.hashCode() ^ positiveSuffix.hashCode());
// FIXME.
return hash;
}
public boolean isDecimalSeparatorAlwaysShown ()
{
return decimalSeparatorAlwaysShown;
}
public Number parse (String str, ParsePosition pos)
{
/*
* Our strategy is simple: copy the text into separate buffers: one for the int part,
* one for the fraction part and for the exponential part.
* We translate or omit locale-specific information.
* If exponential is sufficiently big we merge the fraction and int part and
* remove the '.' and then we use Long to convert the number. In the other
* case, we use Double to convert the full number.
*/
boolean is_neg = false;
int index = pos.getIndex();
StringBuffer int_buf = new StringBuffer ();
// We have to check both prefixes, because one might be empty. We
// want to pick the longest prefix that matches.
boolean got_pos = str.startsWith(positivePrefix, index);
String np = (negativePrefix != null
? negativePrefix
: positivePrefix + symbols.getMinusSign());
boolean got_neg = str.startsWith(np, index);
if (got_pos && got_neg)
{
// By checking this way, we preserve ambiguity in the case
// where the negative format differs only in suffix. We
// check this again later.
if (np.length() > positivePrefix.length())
{
is_neg = true;
index += np.length();
}
else
index += positivePrefix.length();
}
else if (got_neg)
{
is_neg = true;
index += np.length();
}
else if (got_pos)
index += positivePrefix.length();
else
{
pos.setErrorIndex (index);
return null;
}
// FIXME: handle Inf and NaN.
// FIXME: do we have to respect minimum digits?
// What about multiplier?
StringBuffer buf = int_buf;
StringBuffer frac_buf = null;
StringBuffer exp_buf = null;
int start_index = index;
int max = str.length();
int exp_index = -1;
int last = index + maximumIntegerDigits;
if (maximumFractionDigits > 0)
last += maximumFractionDigits + 1;
if (useExponentialNotation)
last += minExponentDigits + 1;
if (last > 0 && max > last)
max = last;
char zero = symbols.getZeroDigit();
int last_group = -1;
boolean int_part = true;
boolean exp_part = false;
for (; index < max; ++index)
{
char c = str.charAt(index);
// FIXME: what about grouping size?
if (groupingUsed && c == symbols.getGroupingSeparator())
{
if (last_group != -1
&& groupingSize != 0
&& (index - last_group) % groupingSize != 0)
{
pos.setErrorIndex(index);
return null;
}
last_group = index+1;
}
else if (c >= zero && c <= zero + 9)
{
buf.append((char) (c - zero + '0'));
}
else if (parseIntegerOnly)
break;
else if (c == symbols.getDecimalSeparator())
{
if (last_group != -1
&& groupingSize != 0
&& (index - last_group) % groupingSize != 0)
{
pos.setErrorIndex(index);
return null;
}
buf = frac_buf = new StringBuffer();
frac_buf.append('.');
int_part = false;
}
else if (c == symbols.getExponential())
{
buf = exp_buf = new StringBuffer();
int_part = false;
exp_part = true;
exp_index = index+1;
}
else if (exp_part
&& (c == '+' || c == '-' || c == symbols.getMinusSign()))
{
// For exponential notation.
buf.append(c);
}
else
break;
}
if (index == start_index)
{
// Didn't see any digits.
pos.setErrorIndex(index);
return null;
}
// Check the suffix. We must do this before converting the
// buffer to a number to handle the case of a number which is
// the most negative Long.
boolean got_pos_suf = str.startsWith(positiveSuffix, index);
String ns = (negativePrefix == null ? positiveSuffix : negativeSuffix);
boolean got_neg_suf = str.startsWith(ns, index);
if (is_neg)
{
if (! got_neg_suf)
{
pos.setErrorIndex(index);
return null;
}
}
else if (got_pos && got_neg && got_neg_suf)
{
is_neg = true;
}
else if (got_pos != got_pos_suf && got_neg != got_neg_suf)
{
pos.setErrorIndex(index);
return null;
}
String suffix = is_neg ? ns : positiveSuffix;
long parsedMultiplier = 1;
boolean use_long;
if (is_neg)
int_buf.insert(0, '-');
// Now handle the exponential part if there is one.
if (exp_buf != null)
{
int exponent_value;
try
{
exponent_value = Integer.parseInt(exp_buf.toString());
}
catch (NumberFormatException x1)
{
pos.setErrorIndex(exp_index);
return null;
}
if (frac_buf == null)
{
// We only have to add some zeros to the int part.
// Build a multiplier.
for (int i = 0; i < exponent_value; i++)
int_buf.append('0');
use_long = true;
}
else
{
boolean long_sufficient;
if (exponent_value < frac_buf.length()-1)
{
int lastNonNull = -1;
/* We have to check the fraction buffer: it may only be full of '0'
* or be sufficiently filled with it to convert the number into Long.
*/
for (int i = 1; i < frac_buf.length(); i++)
if (frac_buf.charAt(i) != '0')
lastNonNull = i;
long_sufficient = (lastNonNull < 0 || lastNonNull <= exponent_value);
}
else
long_sufficient = true;
if (long_sufficient)
{
for (int i = 1; i < frac_buf.length() && i < exponent_value; i++)
int_buf.append(frac_buf.charAt(i));
for (int i = frac_buf.length()-1; i < exponent_value; i++)
int_buf.append('0');
use_long = true;
}
else
{
/*
* A long type is not sufficient, we build the full buffer to
* be parsed by Double.
*/
int_buf.append(frac_buf);
int_buf.append('E');
int_buf.append(exp_buf);
use_long = false;
}
}
}
else
{
if (frac_buf != null)
{
/* Check whether the fraction buffer contains only '0' */
int i;
for (i = 1; i < frac_buf.length(); i++)
if (frac_buf.charAt(i) != '0')
break;
if (i != frac_buf.length())
{
use_long = false;
int_buf.append(frac_buf);
}
else
use_long = true;
}
else
use_long = true;
}
String t = int_buf.toString();
Number result = null;
if (use_long)
{
try
{
result = new Long (t);
}
catch (NumberFormatException x1)
{
}
}
else
{
try
{
result = new Double (t);
}
catch (NumberFormatException x2)
{
}
}
if (result == null)
{
pos.setErrorIndex(index);
return null;
}
pos.setIndex(index + suffix.length());
return result;
}
/**
* Sets the Currency on the
* DecimalFormatSymbols used, which also sets the
* currency symbols on those symbols.
*/
public void setCurrency(Currency currency)
{
symbols.setCurrency(currency);
}
public void setDecimalFormatSymbols (DecimalFormatSymbols newSymbols)
{
symbols = newSymbols;
}
public void setDecimalSeparatorAlwaysShown (boolean newValue)
{
decimalSeparatorAlwaysShown = newValue;
}
public void setGroupingSize (int groupSize)
{
groupingSize = (byte) groupSize;
}
public void setMaximumFractionDigits (int newValue)
{
super.setMaximumFractionDigits(Math.min(newValue, 340));
}
public void setMaximumIntegerDigits (int newValue)
{
super.setMaximumIntegerDigits(Math.min(newValue, 309));
}
public void setMinimumFractionDigits (int newValue)
{
super.setMinimumFractionDigits(Math.min(newValue, 340));
}
public void setMinimumIntegerDigits (int newValue)
{
super.setMinimumIntegerDigits(Math.min(newValue, 309));
}
public void setMultiplier (int newValue)
{
multiplier = newValue;
}
public void setNegativePrefix (String newValue)
{
negativePrefix = newValue;
}
public void setNegativeSuffix (String newValue)
{
negativeSuffix = newValue;
}
public void setPositivePrefix (String newValue)
{
positivePrefix = newValue;
}
public void setPositiveSuffix (String newValue)
{
positiveSuffix = newValue;
}
private void quoteFix(StringBuffer buf, String text, String patChars)
{
int len = text.length();
for (int index = 0; index < len; ++index)
{
char c = text.charAt(index);
if (patChars.indexOf(c) != -1)
{
buf.append('\'');
buf.append(c);
buf.append('\'');
}
else
buf.append(c);
}
}
private String computePattern(DecimalFormatSymbols syms)
{
StringBuffer mainPattern = new StringBuffer ();
// We have to at least emit a zero for the minimum number of
// digits. Past that we need hash marks up to the grouping
// separator (and one beyond).
int total_digits = Math.max(minimumIntegerDigits,
groupingUsed ? groupingSize + 1: groupingSize);
for (int i = 0; i < total_digits - minimumIntegerDigits; ++i)
mainPattern.append(syms.getDigit());
for (int i = total_digits - minimumIntegerDigits; i < total_digits; ++i)
mainPattern.append(syms.getZeroDigit());
// Inserting the gropuing operator afterwards is easier.
if (groupingUsed)
mainPattern.insert(mainPattern.length() - groupingSize,
syms.getGroupingSeparator());
// See if we need decimal info.
if (minimumFractionDigits > 0 || maximumFractionDigits > 0
|| decimalSeparatorAlwaysShown)
mainPattern.append(syms.getDecimalSeparator());
for (int i = 0; i < minimumFractionDigits; ++i)
mainPattern.append(syms.getZeroDigit());
for (int i = minimumFractionDigits; i < maximumFractionDigits; ++i)
mainPattern.append(syms.getDigit());
if (useExponentialNotation)
{
mainPattern.append(syms.getExponential());
for (int i = 0; i < minExponentDigits; ++i)
mainPattern.append(syms.getZeroDigit());
if (minExponentDigits == 0)
mainPattern.append(syms.getDigit());
}
String main = mainPattern.toString();
String patChars = patternChars (syms);
mainPattern.setLength(0);
quoteFix (mainPattern, positivePrefix, patChars);
mainPattern.append(main);
quoteFix (mainPattern, positiveSuffix, patChars);
if (negativePrefix != null)
{
quoteFix (mainPattern, negativePrefix, patChars);
mainPattern.append(main);
quoteFix (mainPattern, negativeSuffix, patChars);
}
return mainPattern.toString();
}
public String toLocalizedPattern ()
{
return computePattern (symbols);
}
public String toPattern ()
{
return computePattern (nonLocalizedSymbols);
}
private static final int MAXIMUM_INTEGER_DIGITS = 309;
// These names are fixed by the serialization spec.
private boolean decimalSeparatorAlwaysShown;
private byte groupingSize;
private byte minExponentDigits;
private int exponentRound;
private int multiplier;
private String negativePrefix;
private String negativeSuffix;
private String positivePrefix;
private String positiveSuffix;
private int[] negativePrefixRanges, positivePrefixRanges;
private HashMap[] negativePrefixAttrs, positivePrefixAttrs;
private int[] negativeSuffixRanges, positiveSuffixRanges;
private HashMap[] negativeSuffixAttrs, positiveSuffixAttrs;
private int serialVersionOnStream = 1;
private DecimalFormatSymbols symbols;
private boolean useExponentialNotation;
private static final long serialVersionUID = 864413376551465018L;
private void readObject(ObjectInputStream stream)
throws IOException, ClassNotFoundException
{
stream.defaultReadObject();
if (serialVersionOnStream < 1)
{
useExponentialNotation = false;
serialVersionOnStream = 1;
}
}
// The locale-independent pattern symbols happen to be the same as
// the US symbols.
private static final DecimalFormatSymbols nonLocalizedSymbols
= new DecimalFormatSymbols (Locale.US);
/**
* * Substitutes the currency symbol into the given string, * based on the value used. Currency symbols can either * be a simple series of characters (e.g. '$'), which are * simply used as is, or they can be of a more complex * form: *
** (lower bound)|(mid value)|(upper bound) *
** where each bound has the syntax '(value)(# or <)(symbol)', * to indicate the bounding value and the symbol used. *
** The currency symbol replaces the currency specifier, '\u00a4', * an unlocalised character, which thus is used as such in all formats. * If this symbol occurs twice, the international currency code is used * instead. *
* * @param string The string containing the currency specifier, '\u00a4'. * @param number the number being formatted. * @return a string formatted for the correct currency. */ private String substituteCurrency(String string, double number) { int index; int length; char currentChar; StringBuffer buf; index = 0; length = string.length(); buf = new StringBuffer(); while (index < length) { currentChar = string.charAt(index); if (string.charAt(index) == '\u00a4') { if ((index + 1) < length && string.charAt(index + 1) == '\u00a4') { buf.append(symbols.getInternationalCurrencySymbol()); index += 2; } else { String symbol; symbol = symbols.getCurrencySymbol(); if (symbol.startsWith("=")) { String[] bounds; int[] boundValues; String[] boundSymbols; bounds = symbol.substring(1).split("\\|"); boundValues = new int[3]; boundSymbols = new String[3]; for (int a = 0; a < 3; ++a) { String[] bound; bound = bounds[a].split("[#<]"); boundValues[a] = Integer.parseInt(bound[0]); boundSymbols[a] = bound[1]; } if (number <= boundValues[0]) { buf.append(boundSymbols[0]); } else if (number >= boundValues[2]) { buf.append(boundSymbols[2]); } else { buf.append(boundSymbols[1]); } ++index; } else { buf.append(symbol); ++index; } } } else { buf.append(string.charAt(index)); ++index; } } return buf.toString(); } }