NumberFormat is the abstract base class for all number
* formats. This class provides the interface for formatting and parsing
* numbers. NumberFormat also provides methods for determining
* which locales have number formats, and what their names are.
*
*
* NumberFormat helps you to format and parse numbers for any locale.
* Your code can be completely independent of the locale conventions for
* decimal points, thousands-separators, or even the particular decimal
* digits used, or whether the number format is even decimal.
*
*
* To format a number for the current Locale, use one of the factory * class methods: *
* {@code
* myString = NumberFormat.getInstance().format(myNumber);
* }
*
* If you are formatting multiple numbers, it is
* more efficient to get the format and use it multiple times so that
* the system doesn't have to fetch the information about the local
* language and country conventions multiple times.
*
* {@code
* NumberFormat nf = NumberFormat.getInstance();
* for (int i = 0; i < myNumber.length; ++i) {
* output.println(nf.format(myNumber[i]) + "; ");
* }
* }
*
* To format a number for a different Locale, specify it in the
* call to getInstance.
*
* {@code
* NumberFormat nf = NumberFormat.getInstance(Locale.FRENCH);
* }
*
* You can also use a NumberFormat to parse numbers:
*
* {@code
* myNumber = nf.parse(myString);
* }
*
* Use getInstance or getNumberInstance to get the
* normal number format. Use getIntegerInstance to get an
* integer number format. Use getCurrencyInstance to get the
* currency number format. And use getPercentInstance to get a
* format for displaying percentages. With this format, a fraction like
* 0.53 is displayed as 53%.
*
*
* You can also control the display of numbers with such methods as
* setMinimumFractionDigits.
* If you want even more control over the format or parsing,
* or want to give your users more control,
* you can try casting the NumberFormat you get from the factory methods
* to a DecimalFormat. This will work for the vast majority
* of locales; just remember to put it in a try block in case you
* encounter an unusual one.
*
*
* NumberFormat and DecimalFormat are designed such that some controls * work for formatting and others work for parsing. The following is * the detailed description for each these control methods, *
* setParseIntegerOnly : only affects parsing, e.g. * if true, "3456.78" → 3456 (and leaves the parse position just after index 6) * if false, "3456.78" → 3456.78 (and leaves the parse position just after index 8) * This is independent of formatting. If you want to not show a decimal point * where there might be no digits after the decimal point, use * setDecimalSeparatorAlwaysShown. *
* setDecimalSeparatorAlwaysShown : only affects formatting, and only where * there might be no digits after the decimal point, such as with a pattern * like "#,##0.##", e.g., * if true, 3456.00 → "3,456." * if false, 3456.00 → "3456" * This is independent of parsing. If you want parsing to stop at the decimal * point, use setParseIntegerOnly. * *
* You can also use forms of the parse and format
* methods with ParsePosition and FieldPosition to
* allow you to:
*
FieldPosition in your format call, with
* field = INTEGER_FIELD. On output,
* getEndIndex will be set to the offset between the
* last character of the integer and the decimal. Add
* (desiredSpaceCount - getEndIndex) spaces at the front of the string.
*
* getEndIndex.
* Then move the pen by
* (desiredPixelWidth - widthToAlignmentPoint) before drawing the text.
* It also works where there is no decimal, but possibly additional
* characters at the end, e.g., with parentheses in negative
* numbers: "(12)" for -12.
* * Number formats are generally not synchronized. * It is recommended to create separate format instances for each thread. * If multiple threads access a format concurrently, it must be synchronized * externally. * * @see DecimalFormat * @see ChoiceFormat * @author Mark Davis * @author Helena Shih */ public abstract class NumberFormat extends Format { /** * Field constant used to construct a FieldPosition object. Signifies that * the position of the integer part of a formatted number should be returned. * @see java.text.FieldPosition */ public static final int INTEGER_FIELD = 0; /** * Field constant used to construct a FieldPosition object. Signifies that * the position of the fraction part of a formatted number should be returned. * @see java.text.FieldPosition */ public static final int FRACTION_FIELD = 1; /** * Sole constructor. (For invocation by subclass constructors, typically * implicit.) */ protected NumberFormat() { } /** * Formats a number and appends the resulting text to the given string * buffer. * The number can be of any subclass of {@link java.lang.Number}. *
* This implementation extracts the number's value using
* {@link java.lang.Number#longValue()} for all integral type values that
* can be converted to long without loss of information,
* including BigInteger values with a
* {@link java.math.BigInteger#bitLength() bit length} of less than 64,
* and {@link java.lang.Number#doubleValue()} for all other types. It
* then calls
* {@link #format(long,java.lang.StringBuffer,java.text.FieldPosition)}
* or {@link #format(double,java.lang.StringBuffer,java.text.FieldPosition)}.
* This may result in loss of magnitude information and precision for
* BigInteger and BigDecimal values.
* @param number the number to format
* @param toAppendTo the StringBuffer to which the formatted
* text is to be appended
* @param pos On input: an alignment field, if desired.
* On output: the offsets of the alignment field.
* @return the value passed in as toAppendTo
* @exception IllegalArgumentException if number is
* null or not an instance of Number.
* @exception NullPointerException if toAppendTo or
* pos is null
* @exception ArithmeticException if rounding is needed with rounding
* mode being set to RoundingMode.UNNECESSARY
* @see java.text.FieldPosition
*/
@Override
public StringBuffer format(Object number,
StringBuffer toAppendTo,
FieldPosition pos) {
if (number instanceof Long || number instanceof Integer ||
number instanceof Short || number instanceof Byte ||
number instanceof AtomicInteger || number instanceof AtomicLong ||
(number instanceof BigInteger &&
((BigInteger)number).bitLength() < 64)) {
return format(((Number)number).longValue(), toAppendTo, pos);
} else if (number instanceof Number) {
return format(((Number)number).doubleValue(), toAppendTo, pos);
} else {
throw new IllegalArgumentException("Cannot format given Object as a Number");
}
}
/**
* Parses text from a string to produce a Number.
*
* The method attempts to parse text starting at the index given by
* pos.
* If parsing succeeds, then the index of pos is updated
* to the index after the last character used (parsing does not necessarily
* use all characters up to the end of the string), and the parsed
* number is returned. The updated pos can be used to
* indicate the starting point for the next call to this method.
* If an error occurs, then the index of pos is not
* changed, the error index of pos is set to the index of
* the character where the error occurred, and null is returned.
*
* See the {@link #parse(String, ParsePosition)} method for more information
* on number parsing.
*
* @param source A String, part of which should be parsed.
* @param pos A ParsePosition object with index and error
* index information as described above.
* @return A Number parsed from the string. In case of
* error, returns null.
* @exception NullPointerException if pos is null.
*/
@Override
public final Object parseObject(String source, ParsePosition pos) {
return parse(source, pos);
}
/**
* Specialization of format.
*
* @param number the double number to format
* @return the formatted String
* @exception ArithmeticException if rounding is needed with rounding
* mode being set to RoundingMode.UNNECESSARY
* @see java.text.Format#format
*/
public final String format(double number) {
return format(number, new StringBuffer(),
DontCareFieldPosition.INSTANCE).toString();
}
/**
* Specialization of format.
*
* @param number the long number to format
* @return the formatted String
* @exception ArithmeticException if rounding is needed with rounding
* mode being set to RoundingMode.UNNECESSARY
* @see java.text.Format#format
*/
public final String format(long number) {
return format(number, new StringBuffer(),
DontCareFieldPosition.INSTANCE).toString();
}
/**
* Specialization of format.
*
* @param number the double number to format
* @param toAppendTo the StringBuffer to which the formatted text is to be
* appended
* @param pos the field position
* @return the formatted StringBuffer
* @exception ArithmeticException if rounding is needed with rounding
* mode being set to RoundingMode.UNNECESSARY
* @see java.text.Format#format
*/
public abstract StringBuffer format(double number,
StringBuffer toAppendTo,
FieldPosition pos);
/**
* Specialization of format.
*
* @param number the long number to format
* @param toAppendTo the StringBuffer to which the formatted text is to be
* appended
* @param pos the field position
* @return the formatted StringBuffer
* @exception ArithmeticException if rounding is needed with rounding
* mode being set to RoundingMode.UNNECESSARY
* @see java.text.Format#format
*/
public abstract StringBuffer format(long number,
StringBuffer toAppendTo,
FieldPosition pos);
/**
* Returns a Long if possible (e.g., within the range [Long.MIN_VALUE,
* Long.MAX_VALUE] and with no decimals), otherwise a Double.
* If IntegerOnly is set, will stop at a decimal
* point (or equivalent; e.g., for rational numbers "1 2/3", will stop
* after the 1).
* Does not throw an exception; if no object can be parsed, index is
* unchanged!
*
* @param source the String to parse
* @param parsePosition the parse position
* @return the parsed value
* @see java.text.NumberFormat#isParseIntegerOnly
* @see java.text.Format#parseObject
*/
public abstract Number parse(String source, ParsePosition parsePosition);
/**
* Parses text from the beginning of the given string to produce a number.
* The method may not use the entire text of the given string.
*
* See the {@link #parse(String, ParsePosition)} method for more information
* on number parsing.
*
* @param source A String whose beginning should be parsed.
* @return A Number parsed from the string.
* @exception ParseException if the beginning of the specified string
* cannot be parsed.
*/
public Number parse(String source) throws ParseException {
ParsePosition parsePosition = new ParsePosition(0);
Number result = parse(source, parsePosition);
if (parsePosition.index == 0) {
throw new ParseException("Unparseable number: \"" + source + "\"",
parsePosition.errorIndex);
}
return result;
}
/**
* Returns true if this format will parse numbers as integers only.
* For example in the English locale, with ParseIntegerOnly true, the
* string "1234." would be parsed as the integer value 1234 and parsing
* would stop at the "." character. Of course, the exact format accepted
* by the parse operation is locale dependant and determined by sub-classes
* of NumberFormat.
*
* @return {@code true} if numbers should be parsed as integers only;
* {@code false} otherwise
*/
public boolean isParseIntegerOnly() {
return parseIntegerOnly;
}
/**
* Sets whether or not numbers should be parsed as integers only.
*
* @param value {@code true} if numbers should be parsed as integers only;
* {@code false} otherwise
* @see #isParseIntegerOnly
*/
public void setParseIntegerOnly(boolean value) {
parseIntegerOnly = value;
}
//============== Locale Stuff =====================
/**
* Returns a general-purpose number format for the current default
* {@link java.util.Locale.Category#FORMAT FORMAT} locale.
* This is the same as calling
* {@link #getNumberInstance() getNumberInstance()}.
*
* @return the {@code NumberFormat} instance for general-purpose number
* formatting
*/
public final static NumberFormat getInstance() {
return getInstance(Locale.getDefault(Locale.Category.FORMAT), NUMBERSTYLE);
}
/**
* Returns a general-purpose number format for the specified locale.
* This is the same as calling
* {@link #getNumberInstance(java.util.Locale) getNumberInstance(inLocale)}.
*
* @param inLocale the desired locale
* @return the {@code NumberFormat} instance for general-purpose number
* formatting
*/
public static NumberFormat getInstance(Locale inLocale) {
return getInstance(inLocale, NUMBERSTYLE);
}
/**
* Returns a general-purpose number format for the current default
* {@link java.util.Locale.Category#FORMAT FORMAT} locale.
*
This is equivalent to calling * {@link #getNumberInstance(Locale) * getNumberInstance(Locale.getDefault(Locale.Category.FORMAT))}. * * @return the {@code NumberFormat} instance for general-purpose number * formatting * @see java.util.Locale#getDefault(java.util.Locale.Category) * @see java.util.Locale.Category#FORMAT */ public final static NumberFormat getNumberInstance() { return getInstance(Locale.getDefault(Locale.Category.FORMAT), NUMBERSTYLE); } /** * Returns a general-purpose number format for the specified locale. * * @param inLocale the desired locale * @return the {@code NumberFormat} instance for general-purpose number * formatting */ public static NumberFormat getNumberInstance(Locale inLocale) { return getInstance(inLocale, NUMBERSTYLE); } /** * Returns an integer number format for the current default * {@link java.util.Locale.Category#FORMAT FORMAT} locale. The * returned number format is configured to round floating point numbers * to the nearest integer using half-even rounding (see {@link * java.math.RoundingMode#HALF_EVEN RoundingMode.HALF_EVEN}) for formatting, * and to parse only the integer part of an input string (see {@link * #isParseIntegerOnly isParseIntegerOnly}). *
This is equivalent to calling * {@link #getIntegerInstance(Locale) * getIntegerInstance(Locale.getDefault(Locale.Category.FORMAT))}. * * @see #getRoundingMode() * @see java.util.Locale#getDefault(java.util.Locale.Category) * @see java.util.Locale.Category#FORMAT * @return a number format for integer values * @since 1.4 */ public final static NumberFormat getIntegerInstance() { return getInstance(Locale.getDefault(Locale.Category.FORMAT), INTEGERSTYLE); } /** * Returns an integer number format for the specified locale. The * returned number format is configured to round floating point numbers * to the nearest integer using half-even rounding (see {@link * java.math.RoundingMode#HALF_EVEN RoundingMode.HALF_EVEN}) for formatting, * and to parse only the integer part of an input string (see {@link * #isParseIntegerOnly isParseIntegerOnly}). * * @param inLocale the desired locale * @see #getRoundingMode() * @return a number format for integer values * @since 1.4 */ public static NumberFormat getIntegerInstance(Locale inLocale) { return getInstance(inLocale, INTEGERSTYLE); } /** * Returns a currency format for the current default * {@link java.util.Locale.Category#FORMAT FORMAT} locale. *
This is equivalent to calling * {@link #getCurrencyInstance(Locale) * getCurrencyInstance(Locale.getDefault(Locale.Category.FORMAT))}. * * @return the {@code NumberFormat} instance for currency formatting * @see java.util.Locale#getDefault(java.util.Locale.Category) * @see java.util.Locale.Category#FORMAT */ public final static NumberFormat getCurrencyInstance() { return getInstance(Locale.getDefault(Locale.Category.FORMAT), CURRENCYSTYLE); } /** * Returns a currency format for the specified locale. * * @param inLocale the desired locale * @return the {@code NumberFormat} instance for currency formatting */ public static NumberFormat getCurrencyInstance(Locale inLocale) { return getInstance(inLocale, CURRENCYSTYLE); } /** * Returns a percentage format for the current default * {@link java.util.Locale.Category#FORMAT FORMAT} locale. *
This is equivalent to calling
* {@link #getPercentInstance(Locale)
* getPercentInstance(Locale.getDefault(Locale.Category.FORMAT))}.
*
* @return the {@code NumberFormat} instance for percentage formatting
* @see java.util.Locale#getDefault(java.util.Locale.Category)
* @see java.util.Locale.Category#FORMAT
*/
public final static NumberFormat getPercentInstance() {
return getInstance(Locale.getDefault(Locale.Category.FORMAT), PERCENTSTYLE);
}
/**
* Returns a percentage format for the specified locale.
*
* @param inLocale the desired locale
* @return the {@code NumberFormat} instance for percentage formatting
*/
public static NumberFormat getPercentInstance(Locale inLocale) {
return getInstance(inLocale, PERCENTSTYLE);
}
// Android-changed: Removed reference to NumberFormatProvider.
/**
* Returns an array of all locales for which the
* get*Instance methods of this class can return
* localized instances.
*
* @return An array of locales for which localized
* NumberFormat instances are available.
*/
public static Locale[] getAvailableLocales() {
// Android-changed: Removed used of NumberFormatProvider. Switched to use ICU.
return ICU.getAvailableLocales();
}
/**
* Overrides hashCode.
*/
@Override
public int hashCode() {
return maximumIntegerDigits * 37 + maxFractionDigits;
// just enough fields for a reasonable distribution
}
/**
* Overrides equals.
*/
@Override
public boolean equals(Object obj) {
if (obj == null) {
return false;
}
if (this == obj) {
return true;
}
if (getClass() != obj.getClass()) {
return false;
}
NumberFormat other = (NumberFormat) obj;
return (maximumIntegerDigits == other.maximumIntegerDigits
&& minimumIntegerDigits == other.minimumIntegerDigits
&& maximumFractionDigits == other.maximumFractionDigits
&& minimumFractionDigits == other.minimumFractionDigits
&& groupingUsed == other.groupingUsed
&& parseIntegerOnly == other.parseIntegerOnly);
}
/**
* Overrides Cloneable.
*/
@Override
public Object clone() {
NumberFormat other = (NumberFormat) super.clone();
return other;
}
/**
* Returns true if grouping is used in this format. For example, in the
* English locale, with grouping on, the number 1234567 might be formatted
* as "1,234,567". The grouping separator as well as the size of each group
* is locale dependant and is determined by sub-classes of NumberFormat.
*
* @return {@code true} if grouping is used;
* {@code false} otherwise
* @see #setGroupingUsed
*/
public boolean isGroupingUsed() {
return groupingUsed;
}
/**
* Set whether or not grouping will be used in this format.
*
* @param newValue {@code true} if grouping is used;
* {@code false} otherwise
* @see #isGroupingUsed
*/
public void setGroupingUsed(boolean newValue) {
groupingUsed = newValue;
}
/**
* Returns the maximum number of digits allowed in the integer portion of a
* number.
*
* @return the maximum number of digits
* @see #setMaximumIntegerDigits
*/
public int getMaximumIntegerDigits() {
return maximumIntegerDigits;
}
/**
* Sets the maximum number of digits allowed in the integer portion of a
* number. maximumIntegerDigits must be ≥ minimumIntegerDigits. If the
* new value for maximumIntegerDigits is less than the current value
* of minimumIntegerDigits, then minimumIntegerDigits will also be set to
* the new value.
*
* @param newValue the maximum number of integer digits to be shown; if
* less than zero, then zero is used. The concrete subclass may enforce an
* upper limit to this value appropriate to the numeric type being formatted.
* @see #getMaximumIntegerDigits
*/
public void setMaximumIntegerDigits(int newValue) {
maximumIntegerDigits = Math.max(0,newValue);
if (minimumIntegerDigits > maximumIntegerDigits) {
minimumIntegerDigits = maximumIntegerDigits;
}
}
/**
* Returns the minimum number of digits allowed in the integer portion of a
* number.
*
* @return the minimum number of digits
* @see #setMinimumIntegerDigits
*/
public int getMinimumIntegerDigits() {
return minimumIntegerDigits;
}
/**
* Sets the minimum number of digits allowed in the integer portion of a
* number. minimumIntegerDigits must be ≤ maximumIntegerDigits. If the
* new value for minimumIntegerDigits exceeds the current value
* of maximumIntegerDigits, then maximumIntegerDigits will also be set to
* the new value
*
* @param newValue the minimum number of integer digits to be shown; if
* less than zero, then zero is used. The concrete subclass may enforce an
* upper limit to this value appropriate to the numeric type being formatted.
* @see #getMinimumIntegerDigits
*/
public void setMinimumIntegerDigits(int newValue) {
minimumIntegerDigits = Math.max(0,newValue);
if (minimumIntegerDigits > maximumIntegerDigits) {
maximumIntegerDigits = minimumIntegerDigits;
}
}
/**
* Returns the maximum number of digits allowed in the fraction portion of a
* number.
*
* @return the maximum number of digits.
* @see #setMaximumFractionDigits
*/
public int getMaximumFractionDigits() {
return maximumFractionDigits;
}
/**
* Sets the maximum number of digits allowed in the fraction portion of a
* number. maximumFractionDigits must be ≥ minimumFractionDigits. If the
* new value for maximumFractionDigits is less than the current value
* of minimumFractionDigits, then minimumFractionDigits will also be set to
* the new value.
*
* @param newValue the maximum number of fraction digits to be shown; if
* less than zero, then zero is used. The concrete subclass may enforce an
* upper limit to this value appropriate to the numeric type being formatted.
* @see #getMaximumFractionDigits
*/
public void setMaximumFractionDigits(int newValue) {
maximumFractionDigits = Math.max(0,newValue);
if (maximumFractionDigits < minimumFractionDigits) {
minimumFractionDigits = maximumFractionDigits;
}
}
/**
* Returns the minimum number of digits allowed in the fraction portion of a
* number.
*
* @return the minimum number of digits
* @see #setMinimumFractionDigits
*/
public int getMinimumFractionDigits() {
return minimumFractionDigits;
}
/**
* Sets the minimum number of digits allowed in the fraction portion of a
* number. minimumFractionDigits must be ≤ maximumFractionDigits. If the
* new value for minimumFractionDigits exceeds the current value
* of maximumFractionDigits, then maximumIntegerDigits will also be set to
* the new value
*
* @param newValue the minimum number of fraction digits to be shown; if
* less than zero, then zero is used. The concrete subclass may enforce an
* upper limit to this value appropriate to the numeric type being formatted.
* @see #getMinimumFractionDigits
*/
public void setMinimumFractionDigits(int newValue) {
minimumFractionDigits = Math.max(0,newValue);
if (maximumFractionDigits < minimumFractionDigits) {
maximumFractionDigits = minimumFractionDigits;
}
}
/**
* Gets the currency used by this number format when formatting
* currency values. The initial value is derived in a locale dependent
* way. The returned value may be null if no valid
* currency could be determined and no currency has been set using
* {@link #setCurrency(java.util.Currency) setCurrency}.
*
* The default implementation throws
* UnsupportedOperationException.
*
* @return the currency used by this number format, or null
* @exception UnsupportedOperationException if the number format class
* doesn't implement currency formatting
* @since 1.4
*/
public Currency getCurrency() {
throw new UnsupportedOperationException();
}
/**
* Sets the currency used by this number format when formatting
* currency values. This does not update the minimum or maximum
* number of fraction digits used by the number format.
*
* The default implementation throws
* UnsupportedOperationException.
*
* @param currency the new currency to be used by this number format
* @exception UnsupportedOperationException if the number format class
* doesn't implement currency formatting
* @exception NullPointerException if currency is null
* @since 1.4
*/
public void setCurrency(Currency currency) {
throw new UnsupportedOperationException();
}
/**
* Gets the {@link java.math.RoundingMode} used in this NumberFormat.
* The default implementation of this method in NumberFormat
* always throws {@link java.lang.UnsupportedOperationException}.
* Subclasses which handle different rounding modes should override
* this method.
*
* @exception UnsupportedOperationException The default implementation
* always throws this exception
* @return The RoundingMode used for this NumberFormat.
* @see #setRoundingMode(RoundingMode)
* @since 1.6
*/
public RoundingMode getRoundingMode() {
throw new UnsupportedOperationException();
}
/**
* Sets the {@link java.math.RoundingMode} used in this NumberFormat.
* The default implementation of this method in NumberFormat always
* throws {@link java.lang.UnsupportedOperationException}.
* Subclasses which handle different rounding modes should override
* this method.
*
* @exception UnsupportedOperationException The default implementation
* always throws this exception
* @exception NullPointerException if roundingMode is null
* @param roundingMode The RoundingMode to be used
* @see #getRoundingMode()
* @since 1.6
*/
public void setRoundingMode(RoundingMode roundingMode) {
throw new UnsupportedOperationException();
}
// =======================privates===============================
private static NumberFormat getInstance(Locale desiredLocale,
int choice) {
// Android-changed: Removed use of NumberFormatProvider. Switched to use ICU.
/* try the cache first */
String[] numberPatterns = (String[])cachedLocaleData.get(desiredLocale);
if (numberPatterns == null) { /* cache miss */
LocaleData data = LocaleData.get(desiredLocale);
numberPatterns = new String[4];
numberPatterns[NUMBERSTYLE] = data.numberPattern;
numberPatterns[CURRENCYSTYLE] = data.currencyPattern;
numberPatterns[PERCENTSTYLE] = data.percentPattern;
numberPatterns[INTEGERSTYLE] = data.integerPattern;
/* update cache */
cachedLocaleData.put(desiredLocale, numberPatterns);
}
DecimalFormatSymbols symbols = DecimalFormatSymbols.getInstance(desiredLocale);
int entry = (choice == INTEGERSTYLE) ? NUMBERSTYLE : choice;
DecimalFormat format = new DecimalFormat(numberPatterns[entry], symbols);
if (choice == INTEGERSTYLE) {
format.setMaximumFractionDigits(0);
format.setDecimalSeparatorAlwaysShown(false);
format.setParseIntegerOnly(true);
} else if (choice == CURRENCYSTYLE) {
format.adjustForCurrencyDefaultFractionDigits();
}
return format;
}
/**
* First, read in the default serializable data.
*
* Then, if serialVersionOnStream is less than 1, indicating that
* the stream was written by JDK 1.1,
* set the int fields such as maximumIntegerDigits
* to be equal to the byte fields such as maxIntegerDigits,
* since the int fields were not present in JDK 1.1.
* Finally, set serialVersionOnStream back to the maximum allowed value so that
* default serialization will work properly if this object is streamed out again.
*
*
If minimumIntegerDigits is greater than
* maximumIntegerDigits or minimumFractionDigits
* is greater than maximumFractionDigits, then the stream data
* is invalid and this method throws an InvalidObjectException.
* In addition, if any of these values is negative, then this method throws
* an InvalidObjectException.
*
* @since 1.2
*/
private void readObject(ObjectInputStream stream)
throws IOException, ClassNotFoundException
{
stream.defaultReadObject();
if (serialVersionOnStream < 1) {
// Didn't have additional int fields, reassign to use them.
maximumIntegerDigits = maxIntegerDigits;
minimumIntegerDigits = minIntegerDigits;
maximumFractionDigits = maxFractionDigits;
minimumFractionDigits = minFractionDigits;
}
if (minimumIntegerDigits > maximumIntegerDigits ||
minimumFractionDigits > maximumFractionDigits ||
minimumIntegerDigits < 0 || minimumFractionDigits < 0) {
throw new InvalidObjectException("Digit count range invalid");
}
serialVersionOnStream = currentSerialVersion;
}
/**
* Write out the default serializable data, after first setting
* the byte fields such as maxIntegerDigits to be
* equal to the int fields such as maximumIntegerDigits
* (or to Byte.MAX_VALUE, whichever is smaller), for compatibility
* with the JDK 1.1 version of the stream format.
*
* @since 1.2
*/
private void writeObject(ObjectOutputStream stream)
throws IOException
{
maxIntegerDigits = (maximumIntegerDigits > Byte.MAX_VALUE) ?
Byte.MAX_VALUE : (byte)maximumIntegerDigits;
minIntegerDigits = (minimumIntegerDigits > Byte.MAX_VALUE) ?
Byte.MAX_VALUE : (byte)minimumIntegerDigits;
maxFractionDigits = (maximumFractionDigits > Byte.MAX_VALUE) ?
Byte.MAX_VALUE : (byte)maximumFractionDigits;
minFractionDigits = (minimumFractionDigits > Byte.MAX_VALUE) ?
Byte.MAX_VALUE : (byte)minimumFractionDigits;
stream.defaultWriteObject();
}
/**
* Cache to hold the NumberPatterns of a Locale.
*/
private static final Hashtable cachedLocaleData = new Hashtable(3);
// Constants used by factory methods to specify a style of format.
private static final int NUMBERSTYLE = 0;
private static final int CURRENCYSTYLE = 1;
private static final int PERCENTSTYLE = 2;
private static final int INTEGERSTYLE = 3;
/**
* True if the grouping (i.e. thousands) separator is used when
* formatting and parsing numbers.
*
* @serial
* @see #isGroupingUsed
*/
private boolean groupingUsed = true;
/**
* The maximum number of digits allowed in the integer portion of a
* number. maxIntegerDigits must be greater than or equal to
* minIntegerDigits.
*
* Note: This field exists only for serialization
* compatibility with JDK 1.1. In Java platform 2 v1.2 and higher, the new
* int field maximumIntegerDigits is used instead.
* When writing to a stream, maxIntegerDigits is set to
* maximumIntegerDigits or Byte.MAX_VALUE,
* whichever is smaller. When reading from a stream, this field is used
* only if serialVersionOnStream is less than 1.
*
* @serial
* @see #getMaximumIntegerDigits
*/
private byte maxIntegerDigits = 40;
/**
* The minimum number of digits allowed in the integer portion of a
* number. minimumIntegerDigits must be less than or equal to
* maximumIntegerDigits.
*
* Note: This field exists only for serialization
* compatibility with JDK 1.1. In Java platform 2 v1.2 and higher, the new
* int field minimumIntegerDigits is used instead.
* When writing to a stream, minIntegerDigits is set to
* minimumIntegerDigits or Byte.MAX_VALUE,
* whichever is smaller. When reading from a stream, this field is used
* only if serialVersionOnStream is less than 1.
*
* @serial
* @see #getMinimumIntegerDigits
*/
private byte minIntegerDigits = 1;
/**
* The maximum number of digits allowed in the fractional portion of a
* number. maximumFractionDigits must be greater than or equal to
* minimumFractionDigits.
*
* Note: This field exists only for serialization
* compatibility with JDK 1.1. In Java platform 2 v1.2 and higher, the new
* int field maximumFractionDigits is used instead.
* When writing to a stream, maxFractionDigits is set to
* maximumFractionDigits or Byte.MAX_VALUE,
* whichever is smaller. When reading from a stream, this field is used
* only if serialVersionOnStream is less than 1.
*
* @serial
* @see #getMaximumFractionDigits
*/
private byte maxFractionDigits = 3; // invariant, >= minFractionDigits
/**
* The minimum number of digits allowed in the fractional portion of a
* number. minimumFractionDigits must be less than or equal to
* maximumFractionDigits.
*
* Note: This field exists only for serialization
* compatibility with JDK 1.1. In Java platform 2 v1.2 and higher, the new
* int field minimumFractionDigits is used instead.
* When writing to a stream, minFractionDigits is set to
* minimumFractionDigits or Byte.MAX_VALUE,
* whichever is smaller. When reading from a stream, this field is used
* only if serialVersionOnStream is less than 1.
*
* @serial
* @see #getMinimumFractionDigits
*/
private byte minFractionDigits = 0;
/**
* True if this format will parse numbers as integers only.
*
* @serial
* @see #isParseIntegerOnly
*/
private boolean parseIntegerOnly = false;
// new fields for 1.2. byte is too small for integer digits.
/**
* The maximum number of digits allowed in the integer portion of a
* number. maximumIntegerDigits must be greater than or equal to
* minimumIntegerDigits.
*
* @serial
* @since 1.2
* @see #getMaximumIntegerDigits
*/
private int maximumIntegerDigits = 40;
/**
* The minimum number of digits allowed in the integer portion of a
* number. minimumIntegerDigits must be less than or equal to
* maximumIntegerDigits.
*
* @serial
* @since 1.2
* @see #getMinimumIntegerDigits
*/
private int minimumIntegerDigits = 1;
/**
* The maximum number of digits allowed in the fractional portion of a
* number. maximumFractionDigits must be greater than or equal to
* minimumFractionDigits.
*
* @serial
* @since 1.2
* @see #getMaximumFractionDigits
*/
private int maximumFractionDigits = 3; // invariant, >= minFractionDigits
/**
* The minimum number of digits allowed in the fractional portion of a
* number. minimumFractionDigits must be less than or equal to
* maximumFractionDigits.
*
* @serial
* @since 1.2
* @see #getMinimumFractionDigits
*/
private int minimumFractionDigits = 0;
static final int currentSerialVersion = 1;
/**
* Describes the version of NumberFormat present on the stream.
* Possible values are:
*
int fields such as
* maximumIntegerDigits were not present, and the byte
* fields such as maxIntegerDigits are used instead.
*
* byte fields such as maxIntegerDigits are ignored,
* and the int fields such as maximumIntegerDigits
* are used instead.
* NumberFormat, the most recent format
* (corresponding to the highest allowable serialVersionOnStream)
* is always written.
*
* @serial
* @since 1.2
*/
private int serialVersionOnStream = currentSerialVersion;
// Removed "implements Cloneable" clause. Needs to update serialization
// ID for backward compatibility.
static final long serialVersionUID = -2308460125733713944L;
//
// class for AttributedCharacterIterator attributes
//
/**
* Defines constants that are used as attribute keys in the
* AttributedCharacterIterator returned
* from NumberFormat.formatToCharacterIterator and as
* field identifiers in FieldPosition.
*
* @since 1.4
*/
public static class Field extends Format.Field {
// Proclaim serial compatibility with 1.4 FCS
private static final long serialVersionUID = 7494728892700160890L;
// table of all instances in this class, used by readResolve
private static final Map