Also see:

java.text.FieldPosition

Also see:

java.text.FieldPosition

 protected NumberFormat() 
{

}

Sole constructor. (For invocation by subclass constructors, typically implicit.)

 public Object clone() 
{
        NumberFormat other = (NumberFormat) super.clone();
        return other;
}

Overrides Cloneable

 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 equals

 public final String format(double number) 
{
        return format(number, new StringBuffer(),
                      DontCareFieldPosition.INSTANCE).toString();
}

Specialization of format.

 public final String format(long number) 
{
        return format(number, new StringBuffer(),
                      DontCareFieldPosition.INSTANCE).toString();
}

Specialization of format.

 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");
        }
}

Formats a number and appends the resulting text to the given string buffer. The number can be of any subclass of java.lang.Number .

This implementation extracts the number's value using java.lang.Number#longValue() for all integral type values that can be converted to long without loss of information, including BigInteger values with a bit length of less than 64, and java.lang.Number#doubleValue() for all other types. It then calls #format(long,java.lang.StringBuffer,java.text.FieldPosition) or #format(double,java.lang.StringBuffer,java.text.FieldPosition) . This may result in loss of magnitude information and precision for BigInteger and BigDecimal values.

 abstract public StringBuffer format(double number,
    StringBuffer toAppendTo,
    FieldPosition pos)
Specialization of format.

 abstract public StringBuffer format(long number,
    StringBuffer toAppendTo,
    FieldPosition pos)
Specialization of format.

 public static Locale[] getAvailableLocales() 
{
        LocaleServiceProviderPool pool =
            LocaleServiceProviderPool.getPool(NumberFormatProvider.class);
        return pool.getAvailableLocales();
}

Returns an array of all locales for which the get*Instance methods of this class can return localized instances. The returned array represents the union of locales supported by the Java runtime and by installed NumberFormatProvider implementations. It must contain at least a Locale instance equal to Locale.US .

 public Currency getCurrency() 
{
        throw new UnsupportedOperationException();
}

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

The default implementation throws UnsupportedOperationException.

 public static final NumberFormat getCurrencyInstance() 
{
        return getInstance(Locale.getDefault(Locale.Category.FORMAT), CURRENCYSTYLE);
}

Returns a currency format for the current default locale.

 public static NumberFormat getCurrencyInstance(Locale inLocale) 
{
        return getInstance(inLocale, CURRENCYSTYLE);
}

Returns a currency format for the specified locale.

 public static final NumberFormat getInstance() 
{
        return getInstance(Locale.getDefault(Locale.Category.FORMAT), NUMBERSTYLE);
}

Returns a general-purpose number format for the current default locale. This is the same as calling getNumberInstance() .

 public static NumberFormat getInstance(Locale inLocale) 
{
        return getInstance(inLocale, NUMBERSTYLE);
}

Returns a general-purpose number format for the specified locale. This is the same as calling getNumberInstance(inLocale) .

 public static final NumberFormat getIntegerInstance() 
{
        return getInstance(Locale.getDefault(Locale.Category.FORMAT), INTEGERSTYLE);
}

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 half-even rounding (see RoundingMode.HALF_EVEN ) for formatting, and to parse only the integer part of an input string (see isParseIntegerOnly ).

 public static NumberFormat getIntegerInstance(Locale inLocale) 
{
        return getInstance(inLocale, 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 RoundingMode.HALF_EVEN ) for formatting, and to parse only the integer part of an input string (see isParseIntegerOnly ).

 public int getMaximumFractionDigits() 
{
        return maximumFractionDigits;
}

Returns the maximum number of digits allowed in the fraction portion of a number.

 public int getMaximumIntegerDigits() 
{
        return maximumIntegerDigits;
}

Returns the maximum number of digits allowed in the integer portion of a number.

 public int getMinimumFractionDigits() 
{
        return minimumFractionDigits;
}

Returns the minimum number of digits allowed in the fraction portion of a number.

 public int getMinimumIntegerDigits() 
{
        return minimumIntegerDigits;
}

Returns the minimum number of digits allowed in the integer portion of a number.

 public static final NumberFormat getNumberInstance() 
{
        return getInstance(Locale.getDefault(Locale.Category.FORMAT), NUMBERSTYLE);
}

Returns a general-purpose number format for the current default locale.

 public static NumberFormat getNumberInstance(Locale inLocale) 
{
        return getInstance(inLocale, NUMBERSTYLE);
}

Returns a general-purpose number format for the specified locale.

 public static final NumberFormat getPercentInstance() 
{
        return getInstance(Locale.getDefault(Locale.Category.FORMAT), PERCENTSTYLE);
}

Returns a percentage format for the current default locale.

 public static NumberFormat getPercentInstance(Locale inLocale) 
{
        return getInstance(inLocale, PERCENTSTYLE);
}

Returns a percentage format for the specified locale.

 public RoundingMode getRoundingMode() 
{
        throw new UnsupportedOperationException();
}

Gets the java.math.RoundingMode used in this NumberFormat. The default implementation of this method in NumberFormat always throws java.lang.UnsupportedOperationException . Subclasses which handle different rounding modes should override this method.

 static final NumberFormat getScientificInstance() 
{
        return getInstance(Locale.getDefault(Locale.Category.FORMAT), SCIENTIFICSTYLE);
}

Returns a scientific format for the current default locale.

 static NumberFormat getScientificInstance(Locale inLocale) 
{
        return getInstance(inLocale, SCIENTIFICSTYLE);
}

Returns a scientific format for the specified locale.

 public int hashCode() 
{
        return maximumIntegerDigits * 37 + maxFractionDigits;
        // just enough fields for a reasonable distribution
}

Overrides hashCode

 public boolean isGroupingUsed() 
{
        return groupingUsed;
}

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.

 public boolean isParseIntegerOnly() 
{
        return parseIntegerOnly;
}

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 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;
}

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 #parse(String, ParsePosition) method for more information on number parsing.

 abstract public Number parse(String source,
    ParsePosition parsePosition)
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!

 public final Object parseObject(String source,
    ParsePosition pos) 
{
        return parse(source, pos);
}

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 #parse(String, ParsePosition) method for more information on number parsing.

 public  void setCurrency(Currency currency) 
{
        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.

 public  void setGroupingUsed(boolean newValue) 
{
        groupingUsed = newValue;
}

Set whether or not grouping will be used in this format.

 public  void setMaximumFractionDigits(int newValue) 
{
        maximumFractionDigits = Math.max(0,newValue);
        if (maximumFractionDigits <  minimumFractionDigits) {
            minimumFractionDigits = 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.

 public  void setMaximumIntegerDigits(int newValue) 
{
        maximumIntegerDigits = Math.max(0,newValue);
        if (minimumIntegerDigits  > maximumIntegerDigits) {
            minimumIntegerDigits = 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.

 public  void setMinimumFractionDigits(int newValue) 
{
        minimumFractionDigits = Math.max(0,newValue);
        if (maximumFractionDigits <  minimumFractionDigits) {
            maximumFractionDigits = 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

 public  void setMinimumIntegerDigits(int newValue) 
{
        minimumIntegerDigits = Math.max(0,newValue);
        if (minimumIntegerDigits  > maximumIntegerDigits) {
            maximumIntegerDigits = 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

 public  void setParseIntegerOnly(boolean value) 
{
        parseIntegerOnly = value;
}

Sets whether or not numbers should be parsed as integers only.

 public  void setRoundingMode(RoundingMode roundingMode) 
{
        throw new UnsupportedOperationException();
}

Sets the java.math.RoundingMode used in this NumberFormat. The default implementation of this method in NumberFormat always throws java.lang.UnsupportedOperationException . Subclasses which handle different rounding modes should override this method.