java.text.NumberFormat Maven / Gradle / Ivy
/*
This is not an official specification document, and usage is restricted.
NOTICE
(c) 2005-2007 Sun Microsystems, Inc. All Rights Reserved.
Neither this file nor any files generated from it describe a complete
specification, and they may only be used as described below. For
example, no permission is given for you to incorporate this file, in
whole or in part, in an implementation of a Java specification.
Sun Microsystems Inc. owns the copyright in this file and it is provided
to you for informative, as opposed to normative, use. The file and any
files generated from it may be used to generate other informative
documentation, such as a unified set of documents of API signatures for
a platform that includes technologies expressed as Java APIs. The file
may also be used to produce "compilation stubs," which allow
applications to be compiled and validated for such platforms.
Any work generated from this file, such as unified javadocs or compiled
stub files, must be accompanied by this notice in its entirety.
This work corresponds to the API signatures of JSR 219: Foundation
Profile 1.1. In the event of a discrepency between this work and the
JSR 219 specification, which is available at
http://www.jcp.org/en/jsr/detail?id=219, the latter takes precedence.
*/
package java.text;
import java.io.InvalidObjectException;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.math.BigInteger;
import java.util.Currency;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.Locale;
import java.util.Map;
import java.util.ResourceBundle;
/**
* 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:
*
*
* 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.
*
*
* NumberFormat nf = NumberFormat.getInstance();
* for (int i = 0; i < a.length; ++i) {
* output.println(nf.format(myNumber[i]) + "; ");
* }
*
*
* To format a number for a different Locale, specify it in the
* call to getInstance.
*
*
* NumberFormat nf = NumberFormat.getInstance(Locale.FRENCH);
*
*
* You can also use a NumberFormat to parse numbers:
*
*
* 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:
*
* - progressively parse through pieces of a string
*
- align the decimal point and other areas
*
* For example, you can align numbers in two ways:
*
* - If you are using a monospaced font with spacing for alignment,
* you can pass the
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.
*
* - If you are using proportional fonts,
* instead of padding with spaces, measure the width
* of the string in pixels from the start to
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.
*
*
* Synchronization
*
*
* 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
* @version 1.47, 01/19/00
* @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;
/**
* True if the the grouping (i.e. thousands) separator is used when
* formatting and parsing numbers.
*
* @serial
* @see #isGroupingUsed
*/
private boolean groupingUsed;
/**
* 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;
/**
* 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;
/**
* 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;
/**
* 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;
/**
* True if this format will parse numbers as integers only.
*
* @serial
* @see #isParseIntegerOnly
*/
private boolean parseIntegerOnly;
/**
* 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;
/**
* 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;
/**
* 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;
/**
* 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;
/**
* Describes the version of NumberFormat present on the stream.
* Possible values are:
*
* - 0 (or uninitialized): the JDK 1.1 version of the stream format.
* In this version, the
int fields such as
* maximumIntegerDigits were not present, and the byte
* fields such as maxIntegerDigits are used instead.
*
* - 1: the 1.2 version of the stream format. The values of the
*
byte fields such as maxIntegerDigits are ignored,
* and the int fields such as maximumIntegerDigits
* are used instead.
*
* When streaming out a NumberFormat, the most recent format
* (corresponding to the highest allowable serialVersionOnStream)
* is always written.
*
* @serial
* @since 1.2
*/
private int serialVersionOnStream;
public NumberFormat() { }
/**
* Formats an object to produce a string.
* This general routines allows polymorphic parsing and
* formatting for objects.
* @param number the object to format
* @param toAppendTo where the 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 (this allows chaining,
* as with StringBuffer.append())
* @exception IllegalArgumentException when the Format cannot format the
* given object.
* @see java.text.FieldPosition
*/
public final StringBuffer format(Object number, StringBuffer toAppendTo,
FieldPosition pos)
{
return null;
}
/**
* 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.
*/
public final Object parseObject(String source, ParsePosition pos) {
return null;
}
/**
* Specialization of format.
* @see java.text.Format#format
*/
public final String format(double number) {
return null;
}
/**
* Specialization of format.
* @see java.text.Format#format
*/
public final String format(long number) {
return null;
}
/**
* Specialization of format.
* @see java.text.Format#format
*/
public abstract StringBuffer format(double number, StringBuffer toAppendTo,
FieldPosition pos);
/**
* Specialization of format.
* @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!
* @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 {
return null;
}
/**
* 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.
*/
public boolean isParseIntegerOnly() {
return false;
}
/**
* Sets whether or not numbers should be parsed as integers only.
* @see #isParseIntegerOnly
*/
public void setParseIntegerOnly(boolean value) { }
/**
* Returns the default number format for the current default locale.
* The default format is one of the styles provided by the other
* factory methods: getNumberInstance, getIntegerInstance,
* getCurrencyInstance or getPercentInstance.
* Exactly which one is locale dependant.
*/
public static final NumberFormat getInstance() {
return null;
}
/**
* Returns the default number format for the specified locale.
* The default format is one of the styles provided by the other
* factory methods: getNumberInstance, getIntegerInstance,
* getCurrencyInstance or getPercentInstance.
* Exactly which one is locale dependant.
*/
public static NumberFormat getInstance(Locale inLocale) {
return null;
}
/**
* Returns a general-purpose number format for the current default locale.
*/
public static final NumberFormat getNumberInstance() {
return null;
}
/**
* Returns a general-purpose number format for the specified locale.
*/
public static NumberFormat getNumberInstance(Locale inLocale) {
return null;
}
/**
* Returns an integer number format for the current default locale. The
* returned number format is configured to round floating point numbers
* to the nearest integer using IEEE half-even rounding (see {@link
* java.math.BigDecimal#ROUND_HALF_EVEN ROUND_HALF_EVEN}) for formatting,
* and to parse only the integer part of an input string (see {@link
* #isParseIntegerOnly isParseIntegerOnly}).
* NOTE: java.math.BigDecimal is found in J2ME CDC profiles such as
* J2ME Foundation Profile.
* @return a number format for integer values
* @since 1.4
*/
public static final NumberFormat getIntegerInstance() {
return null;
}
/**
* 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 IEEE half-even rounding (see {@link
* java.math.BigDecimal#ROUND_HALF_EVEN ROUND_HALF_EVEN}) for formatting,
* and to parse only the integer part of an input string (see {@link
* #isParseIntegerOnly isParseIntegerOnly}).
* NOTE: java.math.BigDecimal is found in J2ME CDC profiles such as
* J2ME Foundation Profile.
*
* @param inLocale the locale for which a number format is needed
* @return a number format for integer values
* @since 1.4
*/
public static NumberFormat getIntegerInstance(Locale inLocale) {
return null;
}
/**
* Returns a currency format for the current default locale.
*/
public static final NumberFormat getCurrencyInstance() {
return null;
}
/**
* Returns a currency format for the specified locale.
*/
public static NumberFormat getCurrencyInstance(Locale inLocale) {
return null;
}
/**
* Returns a percentage format for the current default locale.
*/
public static final NumberFormat getPercentInstance() {
return null;
}
/**
* Returns a percentage format for the specified locale.
*/
public static NumberFormat getPercentInstance(Locale inLocale) {
return null;
}
/**
* Get the set of Locales for which NumberFormats are installed
* @return available locales
*/
public static Locale[] getAvailableLocales() {
return null;
}
/**
* Overrides hashCode
*/
public int hashCode() {
return 0;
}
/**
* Overrides equals
*/
public boolean equals(Object obj) {
return false;
}
/**
* Overrides Cloneable
*/
public Object clone() {
return null;
}
/**
* 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.
* @see #setGroupingUsed
*/
public boolean isGroupingUsed() {
return false;
}
/**
* Set whether or not grouping will be used in this format.
* @see #isGroupingUsed
*/
public void setGroupingUsed(boolean newValue) { }
/**
* Returns the maximum number of digits allowed in the integer portion of a
* number.
* @see #setMaximumIntegerDigits
*/
public int getMaximumIntegerDigits() {
return 0;
}
/**
* 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) { }
/**
* Returns the minimum number of digits allowed in the integer portion of a
* number.
* @see #setMinimumIntegerDigits
*/
public int getMinimumIntegerDigits() {
return 0;
}
/**
* 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) { }
/**
* Returns the maximum number of digits allowed in the fraction portion of a
* number.
* @see #setMaximumFractionDigits
*/
public int getMaximumFractionDigits() {
return 0;
}
/**
* 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) { }
/**
* Returns the minimum number of digits allowed in the fraction portion of a
* number.
* @see #setMinimumFractionDigits
*/
public int getMinimumFractionDigits() {
return 0;
}
/**
* 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) { }
/**
* 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() {
return null;
}
/**
* 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) { }
/**
* 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
{ }
/**
* 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 { }
static final long serialVersionUID = -2308460125733713944L;
/**
* 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
{
/**
* Constant identifying the integer field.
*/
public static final java.text.NumberFormat.Field INTEGER = null;
/**
* Constant identifying the fraction field.
*/
public static final java.text.NumberFormat.Field FRACTION = null;
/**
* Constant identifying the exponent field.
*/
public static final java.text.NumberFormat.Field EXPONENT = null;
/**
* Constant identifying the decimal separator field.
*/
public static final java.text.NumberFormat.Field DECIMAL_SEPARATOR =
null;
/**
* Constant identifying the sign field.
*/
public static final java.text.NumberFormat.Field SIGN = null;
/**
* Constant identifying the grouping separator field.
*/
public static final java.text.NumberFormat.Field GROUPING_SEPARATOR =
null;
/**
* Constant identifying the exponent symbol field.
*/
public static final java.text.NumberFormat.Field EXPONENT_SYMBOL = null;
/**
* Constant identifying the percent field.
*/
public static final java.text.NumberFormat.Field PERCENT = null;
/**
* Constant identifying the permille field.
*/
public static final java.text.NumberFormat.Field PERMILLE = null;
/**
* Constant identifying the currency field.
*/
public static final java.text.NumberFormat.Field CURRENCY = null;
/**
* Constant identifying the exponent sign field.
*/
public static final java.text.NumberFormat.Field EXPONENT_SIGN = null;
/**
* Creates a Field instance with the specified
* name.
*
* @param name Name of the attribute
*/
protected Field(String name) {
super(name);
}
/**
* Resolves instances being deserialized to the predefined constants.
*
* @throws InvalidObjectException if the constant could not be
* resolved.
* @return resolved NumberFormat.Field constant
*/
protected Object readResolve() throws InvalidObjectException {
return null;
}
}
}