java.text.DecimalFormat 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.math.BigInteger;
import java.util.ArrayList;
import java.util.Currency;
import java.util.Hashtable;
import java.util.Locale;
import java.util.ResourceBundle;

/** 
 * DecimalFormat is a concrete subclass of
 * NumberFormat that formats decimal numbers. It has a variety of
 * features designed to make it possible to parse and format numbers in any
 * locale, including support for Western, Arabic, and Indic digits.  It also
 * supports different kinds of numbers, including integers (123), fixed-point
 * numbers (123.4), scientific notation (1.23E4), percentages (12%), and
 * currency amounts ($123).  All of these can be localized.
 *
 * 
To obtain a NumberFormat for a specific locale, including the
 * default locale, call one of NumberFormat's factory methods, such
 * as getInstance().  In general, do not call the
 * DecimalFormat constructors directly, since the
 * NumberFormat factory methods may return subclasses other than
 * DecimalFormat. If you need to customize the format object, do
 * something like this:
 *
 * 
 * NumberFormat f = NumberFormat.getInstance(loc);
 * if (f instanceof DecimalFormat) {
 *     ((DecimalFormat) f).setDecimalSeparatorAlwaysShown(true);
 * }
 * 
 *
 * A DecimalFormat comprises a pattern and a set of
 * symbols.  The pattern may be set directly using
 * applyPattern(), or indirectly using the API methods.  The
 * symbols are stored in a DecimalFormatSymbols object.  When using
 * the NumberFormat factory methods, the pattern and symbols are
 * read from localized ResourceBundles.
 *
 * 
Patterns
 *
 * DecimalFormat patterns have the following syntax:
 *  * Pattern:
 *         PositivePattern
 *         PositivePattern ; NegativePattern
 * PositivePattern:
 *         Prefix_opt Number Suffix_opt
 * NegativePattern:
 *         Prefix_opt Number Suffix_opt
 * Prefix:
 *         any Unicode characters except \uFFFE, \uFFFF, and special characters
 * Suffix:
 *         any Unicode characters except \uFFFE, \uFFFF, and special characters
 * Number:
 *         Integer Exponent_opt
 *         Integer . Fraction Exponent_opt
 * Integer:
 *         MinimumInteger
 *         #
 *         # Integer
 *         # , Integer
 * MinimumInteger:
 *         0
 *         0 MinimumInteger
 *         0 , MinimumInteger
 * Fraction:
 *         MinimumFraction_opt OptionalFraction_opt
 * MinimumFraction:
 *         0 MinimumFraction_opt
 * OptionalFraction:
 *         # OptionalFraction_opt
 * Exponent:
 *         E MinimumExponent
 * MinimumExponent:
 *         0 MinimumExponent_opt
 * 
 *
 * A DecimalFormat pattern contains a positive and negative
 * subpattern, for example, "#,##0.00;(#,##0.00)".  Each
 * subpattern has a prefix, numeric part, and suffix. The negative subpattern
 * is optional; if absent, then the positive subpattern prefixed with the
 * localized minus sign (code>'-' in most locales) is used as the
 * negative subpattern. That is, "0.00" alone is equivalent to
 * "0.00;-0.00".  If there is an explicit negative subpattern, it
 * serves only to specify the negative prefix and suffix; the number of digits,
 * minimal digits, and other characteristics are all the same as the positive
 * pattern. That means that "#,##0.0#;(#)" produces precisely
 * the same behavior as "#,##0.0#;(#,##0.0#)".
 *
 * 
The prefixes, suffixes, and various symbols used for infinity, digits,
 * thousands separators, decimal separators, etc. may be set to arbitrary
 * values, and they will appear properly during formatting.  However, care must
 * be taken that the symbols and strings do not conflict, or parsing will be
 * unreliable.  For example, either the positive and negative prefixes or the
 * suffixes must be distinct for DecimalFormat.parse() to be able
 * to distinguish positive from negative values.  (If they are identical, then
 * DecimalFormat will behave as if no negative subpattern was
 * specified.)  Another example is that the decimal separator and thousands
 * separator should be distinct characters, or parsing will be impossible.
 *
 * 
The grouping separator is commonly used for thousands, but in some
 * countries it separates ten-thousands. The grouping size is a constant number
 * of digits between the grouping characters, such as 3 for 100,000,000 or 4 for
 * 1,0000,0000.  If you supply a pattern with multiple grouping characters, the
 * interval between the last one and the end of the integer is the one that is
 * used. So "#,##,###,####" == "######,####" ==
 * "##,####,####".
 *
 * 
Special Pattern Characters
 *
 * Many characters in a pattern are taken literally; they are matched during
 * parsing and output unchanged during formatting.  Special characters, on the
 * other hand, stand for other characters, strings, or classes of characters.
 * They must be quoted, unless noted otherwise, if they are to appear in the
 * prefix or suffix as literals.
 *
 * 
The characters listed here are used in non-localized patterns.  Localized
 * patterns use the corresponding characters taken from this formatter's
 * DecimalFormatSymbols object instead, and these characters lose
 * their special status.  Two exceptions are the currency sign and quote, which
 * are not localized.
 *
 * 

 * 
 *     
 *          
 *          
 *          
 *          
 *          
 *          
 *          
 *          
 *          
 *          
 *          
 *          Symbol
 *          Location
 *          Localized?
 *          Meaning
 *     
0
 *          Number
 *          Yes
 *          Digit
 *     
#
 *          Number
 *          Yes
 *          Digit, zero shows as absent
 *     
.
 *          Number
 *          Yes
 *          Decimal separator or monetary decimal separator
 *     
-
 *          Number
 *          Yes
 *          Minus sign
 *     
,
 *          Number
 *          Yes
 *          Grouping separator
 *     
E
 *          Number
 *          Yes
 *          Separates mantissa and exponent in scientific notation.
 *              Need not be quoted in prefix or suffix.
 *     
;
 *          Subpattern boundary
 *          Yes
 *          Separates positive and negative subpatterns
 *     
%
 *          Prefix or suffix
 *          Yes
 *          Multiply by 100 and show as percentage
 *     
\u2030
 *          Prefix or suffix
 *          Yes
 *          Multiply by 1000 and show as per mille
 *     
¤ (\u00A4)
 *          Prefix or suffix
 *          No
 *          Currency sign, replaced by currency symbol.  If
 *              doubled, replaced by international currency symbol.
 *              If present in a pattern, the monetary decimal separator
 *              is used instead of the decimal separator.
 *     
'
 *          Prefix or suffix
 *          No
 *          Used to quote special characters in a prefix or suffix,
 *              for example, "'#'#" formats 123 to
 *              "#123".  To create a single quote
 *              itself, use two in a row: "# o''clock".
 * 
 * 
 *
 * Scientific Notation
 *
 * Numbers in scientific notation are expressed as the product of a mantissa
 * and a power of ten, for example, 1234 can be expressed as 1.234 x 10^3.  The
 * mantissa is often in the range 1.0 <= x < 10.0, but it need not be.
 * DecimalFormat can be instructed to format and parse scientific
 * notation only via a pattern; there is currently no factory method
 * that creates a scientific notation format.  In a pattern, the exponent
 * character immediately followed by one or more digit characters indicates
 * scientific notation.  Example: "0.###E0" formats the number
 * 1234 as "1.234E3".
 *
 * 

 * The number of digit characters after the exponent character gives the
 * minimum exponent digit count.  There is no maximum.  Negative exponents are
 * formatted using the localized minus sign, not the prefix and suffix
 * from the pattern.  This allows patterns such as "0.###E0 m/s".
 *
 * 
The minimum and maximum number of integer digits are interpreted
 * together:
 *
 * 
 * If the maximum number of integer digits is greater than their minimum number
 * and greater than 1, it forces the exponent to be a multiple of the maximum
 * number of integer digits, and the minimum number of integer digits to be
 * interpreted as 1.  The most common use of this is to generate
 * engineering notation, in which the exponent is a multiple of three,
 * e.g., "##0.#####E0". Using this pattern, the number 12345
 * formats to "12.345E3", and 123456 formats to
 * "123.456E3".
 *
 * 
Otherwise, the minimum number of integer digits is achieved by adjusting the
 * exponent.  Example: 0.00123 formatted with "00.###E0" yields
 * "12.3E-4".
 * 
 *
 * 
The number of significant digits in the mantissa is the sum of the
 * minimum integer and maximum fraction digits, and is
 * unaffected by the maximum integer digits.  For example, 12345 formatted with
 * "##0.##E0" is "12.3E3". To show all digits, set
 * the significant digits count to zero.  The number of significant digits
 * does not affect parsing.
 *
 * 
Exponential patterns may not contain grouping separators.
 * 
 *
 * Rounding
 *
 * DecimalFormat uses half-even rounding (see
 * {@link java.math.BigDecimal#ROUND_HALF_EVEN ROUND_HALF_EVEN}) for
 * formatting.
 * 
 * Digits
 *
 * For formatting, DecimalFormat uses the ten consecutive
 * characters starting with the localized zero digit defined in the
 * DecimalFormatSymbols object as digits. For parsing, these
 * digits as well as all Unicode decimal digits, as defined by
 * {@link Character#digit Character.digit}, are recognized.
 *
 * Special Values
 *
 * NaN is formatted as a single character, typically
 * \uFFFD.  This character is determined by the
 * DecimalFormatSymbols object.  This is the only value for which
 * the prefixes and suffixes are not used.
 *
 * 
Infinity is formatted as a single character, typically
 * \u221E, with the positive or negative prefixes and suffixes
 * applied.  The infinity character is determined by the
 * DecimalFormatSymbols object.
 *
 * 
Negative zero ("-0") parses to Double(-0.0),
 * unless isParseIntegerOnly() is true, in which case it parses to
 * Long(0).
 *
 * Synchronization
 *
 * 
 * Decimal 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.
 *
 * 
Example
 *
 *  * // Print out a number using the localized number, integer, currency,
 * // and percent format for each locale
 * Locale[] locales = NumberFormat.getAvailableLocales();
 * double myNumber = -1234.56;
 * NumberFormat form;
 * for (int j=0; j<4; ++j) {
 *     System.out.println("FORMAT");
 *     for (int i = 0; i < locales.length; ++i) {
 *         if (locales[i].getCountry().length() == 0) {
 *            continue; // Skip language-only locales
 *         }
 *         System.out.print(locales[i].getDisplayName());
 *         switch (j) {
 *         case 0:
 *             form = NumberFormat.getInstance(locales[i]); break;
 *         case 1:
 *             form = NumberFormat.getIntegerInstance(locales[i]); break;
 *         case 2:
 *             form = NumberFormat.getCurrencyInstance(locales[i]); break;
 *         default:
 *             form = NumberFormat.getPercentInstance(locales[i]); break;
 *         }
 *         if (form instanceof DecimalFormat) {
 *             System.out.print(": " + ((DecimalFormat) form).toPattern());
 *         }
 *         System.out.print(" -> " + form.format(myNumber));
 *         try {
 *             System.out.println(" -> " + form.parse(form.format(myNumber)));
 *         } catch (ParseException e) {}
 *     }
 * }
 * 
 *
 * @see          Java Tutorial
 * @see          NumberFormat
 * @see          DecimalFormatSymbols
 * @see          ParsePosition
 * @version      1.65, 01/12/04
 * @author       Mark Davis
 * @author       Alan Liu
 */
public class DecimalFormat extends NumberFormat
{
    /** 
     * The symbol used as a prefix when formatting positive numbers, e.g. "+".
     *
     * @serial
     * @see #getPositivePrefix
     */
    private String positivePrefix;

    /** 
     * The symbol used as a suffix when formatting positive numbers.
     * This is often an empty string.
     *
     * @serial
     * @see #getPositiveSuffix
     */
    private String positiveSuffix;

    /** 
     * The symbol used as a prefix when formatting negative numbers, e.g. "-".
     *
     * @serial
     * @see #getNegativePrefix
     */
    private String negativePrefix;

    /** 
     * The symbol used as a suffix when formatting negative numbers.
     * This is often an empty string.
     *
     * @serial
     * @see #getNegativeSuffix
     */
    private String negativeSuffix;

    /** 
     * The prefix pattern for non-negative numbers.  This variable corresponds
     * to positivePrefix.
     *
     * This pattern is expanded by the method expandAffix() to
     * positivePrefix to update the latter to reflect changes in
     * symbols.  If this variable is null then
     * positivePrefix is taken as a literal value that does not
     * change when symbols changes.  This variable is always
     * null for DecimalFormat objects older than
     * stream version 2 restored from stream.
     *
     * @serial
     * @since 1.3
     */
    private String posPrefixPattern;

    /** 
     * The suffix pattern for non-negative numbers.  This variable corresponds
     * to positiveSuffix.  This variable is analogous to
     * posPrefixPattern; see that variable for further
     * documentation.
     *
     * @serial
     * @since 1.3
     */
    private String posSuffixPattern;

    /** 
     * The prefix pattern for negative numbers.  This variable corresponds
     * to negativePrefix.  This variable is analogous to
     * posPrefixPattern; see that variable for further
     * documentation.
     *
     * @serial
     * @since 1.3
     */
    private String negPrefixPattern;

    /** 
     * The suffix pattern for negative numbers.  This variable corresponds
     * to negativeSuffix.  This variable is analogous to
     * posPrefixPattern; see that variable for further
     * documentation.
     *
     * @serial
     * @since 1.3
     */
    private String negSuffixPattern;

    /** 
     * The multiplier for use in percent, permill, etc.
     *
     * @serial
     * @see #getMultiplier
     */
    private int multiplier;

    /** 
     * The number of digits between grouping separators in the integer
     * portion of a number.  Must be greater than 0 if
     * NumberFormat.groupingUsed is true.
     *
     * @serial
     * @see #getGroupingSize
     * @see java.text.NumberFormat#isGroupingUsed
     */
    private byte groupingSize;

    /** 
     * If true, forces the decimal separator to always appear in a formatted
     * number, even if the fractional part of the number is zero.
     *
     * @serial
     * @see #isDecimalSeparatorAlwaysShown
     */
    private boolean decimalSeparatorAlwaysShown;

    /** 
     * The DecimalFormatSymbols object used by this format.
     * It contains the symbols used to format numbers, e.g. the grouping separator,
     * decimal separator, and so on.
     *
     * @serial
     * @see #setDecimalFormatSymbols
     * @see java.text.DecimalFormatSymbols
     */
    private DecimalFormatSymbols symbols;

    /** 
     * True to force the use of exponential (i.e. scientific) notation when formatting
     * numbers.
     *
     * @serial
     * @since 1.2
     */
    private boolean useExponentialNotation;

    /** 
     * The minimum number of digits used to display the exponent when a number is
     * formatted in exponential notation.  This field is ignored if
     * useExponentialNotation is not true.
     *
     * @serial
     * @since 1.2
     */
    private byte minExponentDigits;

    /** 
     * The internal serial version which says which version was written.
     * Possible values are:
     * 

     * 0 (default): versions before the Java 2 platform v1.2
     * 
1: version for 1.2, which includes the two new fields
     *      useExponentialNotation and minExponentDigits.
     * 
2: version for 1.3 and later, which adds four new fields:
     *      posPrefixPattern, posSuffixPattern,
     *      negPrefixPattern, and negSuffixPattern.
     * 
     * @since 1.2
     * @serial
     */
    private int serialVersionOnStream;

    /** 
     * Creates a DecimalFormat using the default pattern and symbols
     * for the default locale. This is a convenient way to obtain a
     * DecimalFormat when internationalization is not the main concern.
     * 
     * To obtain standard formats for a given locale, use the factory methods
     * on NumberFormat such as getNumberInstance. These factories will
     * return the most appropriate sub-class of NumberFormat for a given
     * locale.
     *
     * @see java.text.NumberFormat#getInstance
     * @see java.text.NumberFormat#getNumberInstance
     * @see java.text.NumberFormat#getCurrencyInstance
     * @see java.text.NumberFormat#getPercentInstance
     */
    public DecimalFormat() { }

    /** 
     * Creates a DecimalFormat using the given pattern and the symbols
     * for the default locale. This is a convenient way to obtain a
     * DecimalFormat when internationalization is not the main concern.
     * 

     * To obtain standard formats for a given locale, use the factory methods
     * on NumberFormat such as getNumberInstance. These factories will
     * return the most appropriate sub-class of NumberFormat for a given
     * locale.
     *
     * @param pattern A non-localized pattern string.
     * @exception NullPointerException if pattern is null
     * @exception IllegalArgumentException if the given pattern is invalid.
     * @see java.text.NumberFormat#getInstance
     * @see java.text.NumberFormat#getNumberInstance
     * @see java.text.NumberFormat#getCurrencyInstance
     * @see java.text.NumberFormat#getPercentInstance
     */
    public DecimalFormat(String pattern) { }

    /** 
     * Creates a DecimalFormat using the given pattern and symbols.
     * Use this constructor when you need to completely customize the
     * behavior of the format.
     * 

     * To obtain standard formats for a given
     * locale, use the factory methods on NumberFormat such as
     * getInstance or getCurrencyInstance. If you need only minor adjustments
     * to a standard format, you can modify the format returned by
     * a NumberFormat factory method.
     *
     * @param pattern a non-localized pattern string
     * @param symbols the set of symbols to be used
     * @exception NullPointerException if any of the given arguments is null
     * @exception IllegalArgumentException if the given pattern is invalid
     * @see java.text.NumberFormat#getInstance
     * @see java.text.NumberFormat#getNumberInstance
     * @see java.text.NumberFormat#getCurrencyInstance
     * @see java.text.NumberFormat#getPercentInstance
     * @see java.text.DecimalFormatSymbols
     */
    public DecimalFormat(String pattern, DecimalFormatSymbols symbols) { }

    /** 
     * Formats a double to produce a string.
     * @param number    The double to format
     * @param result    where the text is to be appended
     * @param fieldPosition    On input: an alignment field, if desired.
     * On output: the offsets of the alignment field.
     * @return The formatted number string
     * @see java.text.FieldPosition
     */
    public StringBuffer format(double number, StringBuffer result, FieldPosition
        fieldPosition)
    {
        return null;
    }

    /** 
     * Format a long to produce a string.
     * @param number    The long to format
     * @param result    where the text is to be appended
     * @param fieldPosition    On input: an alignment field, if desired.
     * On output: the offsets of the alignment field.
     * @return The formatted number string
     * @see java.text.FieldPosition
     */
    public StringBuffer format(long number, StringBuffer result, FieldPosition
        fieldPosition)
    {
        return null;
    }

    /** 
     * Formats an Object producing an AttributedCharacterIterator.
     * You can use the returned AttributedCharacterIterator
     * to build the resulting String, as well as to determine information
     * about the resulting String.
     * 

     * Each attribute key of the AttributedCharacterIterator will be of type
     * NumberFormat.Field, with the attribute value being the
     * same as the attribute key.
     *
     * @exception NullPointerException if obj is null.
     * @exception IllegalArgumentException when the Format cannot format the
     *            given object.
     * @param obj The object to format
     * @return AttributedCharacterIterator describing the formatted value.
     * @since 1.4
     */
    public AttributedCharacterIterator formatToCharacterIterator(Object obj) {
        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.
     * 

     * The most economical subclass that can represent the number given by the
     * string is chosen. Most integer values are returned as Long
     * objects, no matter how they are written: "17" and
     * "17.000" both parse to Long(17). Values that
     * cannot fit into a Long are returned as
     * Doubles. This includes values with a fractional part,
     * infinite values, NaN, and the value -0.0.
     * DecimalFormat does not decide whether to return
     * a Double or a Long based on the presence of a
     * decimal separator in the source string. Doing so would prevent integers
     * that overflow the mantissa of a double, such as
     * "10,000,000,000,000,000.00", from being parsed accurately.
     * Currently, the only classes that parse returns are
     * Long and Double, but callers should not rely
     * on this. Callers may use the Number methods
     * doubleValue, longValue, etc., to obtain the
     * type they want.
     * 

     * DecimalFormat parses all Unicode characters that represent
     * decimal digits, as defined by Character.digit(). In
     * addition, DecimalFormat also recognizes as digits the ten
     * consecutive characters starting with the localized zero digit defined in
     * the DecimalFormatSymbols object.
     *
     * @param text the string to be parsed
     * @param pos A ParsePosition object with index and error
     *            index information as described above.
     * @return the parsed value, or null if the parse fails
     * @exception NullPointerException if text or
     *            pos is null.
     */
    public Number parse(String text, ParsePosition pos) {
        return null;
    }

    /** 
     * Returns the decimal format symbols, which is generally not changed
     * by the programmer or user.
     * @return desired DecimalFormatSymbols
     * @see java.text.DecimalFormatSymbols
     */
    public DecimalFormatSymbols getDecimalFormatSymbols() {
        return null;
    }

    /** 
     * Sets the decimal format symbols, which is generally not changed
     * by the programmer or user.
     * @param newSymbols desired DecimalFormatSymbols
     * @see java.text.DecimalFormatSymbols
     */
    public void setDecimalFormatSymbols(DecimalFormatSymbols newSymbols) { }

    /** 
     * Get the positive prefix.
     * 
Examples: +123, $123, sFr123
     */
    public String getPositivePrefix() {
        return null;
    }

    /** 
     * Set the positive prefix.
     * 
Examples: +123, $123, sFr123
     */
    public void setPositivePrefix(String newValue) { }

    /** 
     * Get the negative prefix.
     * 
Examples: -123, ($123) (with negative suffix), sFr-123
     */
    public String getNegativePrefix() {
        return null;
    }

    /** 
     * Set the negative prefix.
     * 
Examples: -123, ($123) (with negative suffix), sFr-123
     */
    public void setNegativePrefix(String newValue) { }

    /** 
     * Get the positive suffix.
     * 
Example: 123%
     */
    public String getPositiveSuffix() {
        return null;
    }

    /** 
     * Set the positive suffix.
     * 
Example: 123%
     */
    public void setPositiveSuffix(String newValue) { }

    /** 
     * Get the negative suffix.
     * 
Examples: -123%, ($123) (with positive suffixes)
     */
    public String getNegativeSuffix() {
        return null;
    }

    /** 
     * Set the positive suffix.
     * 
Examples: 123%
     */
    public void setNegativeSuffix(String newValue) { }

    /** 
     * Get the multiplier for use in percent, permill, etc.
     * For a percentage, set the suffixes to have "%" and the multiplier to be 100.
     * (For Arabic, use arabic percent symbol).
     * For a permill, set the suffixes to have "?" and the multiplier to be 1000.
     * 
Examples: with 100, 1.23 -> "123", and "123" -> 1.23
     */
    public int getMultiplier() {
        return 0;
    }

    /** 
     * Set the multiplier for use in percent, permill, etc.
     * For a percentage, set the suffixes to have "%" and the multiplier to be 100.
     * (For Arabic, use arabic percent symbol).
     * For a permill, set the suffixes to have "?" and the multiplier to be 1000.
     * 
Examples: with 100, 1.23 -> "123", and "123" -> 1.23
     */
    public void setMultiplier(int newValue) { }

    /** 
     * Return the grouping size. Grouping size is the number of digits between
     * grouping separators in the integer portion of a number.  For example,
     * in the number "123,456.78", the grouping size is 3.
     * @see #setGroupingSize
     * @see java.text.NumberFormat#isGroupingUsed
     * @see java.text.DecimalFormatSymbols#getGroupingSeparator
     */
    public int getGroupingSize() {
        return 0;
    }

    /** 
     * Set the grouping size. Grouping size is the number of digits between
     * grouping separators in the integer portion of a number.  For example,
     * in the number "123,456.78", the grouping size is 3.
     * @see #getGroupingSize
     * @see java.text.NumberFormat#setGroupingUsed
     * @see java.text.DecimalFormatSymbols#setGroupingSeparator
     */
    public void setGroupingSize(int newValue) { }

    /** 
     * Allows you to get the behavior of the decimal separator with integers.
     * (The decimal separator will always appear with decimals.)
     * 
Example: Decimal ON: 12345 -> 12345.; OFF: 12345 -> 12345
     */
    public boolean isDecimalSeparatorAlwaysShown() {
        return false;
    }

    /** 
     * Allows you to set the behavior of the decimal separator with integers.
     * (The decimal separator will always appear with decimals.)
     * 
Example: Decimal ON: 12345 -> 12345.; OFF: 12345 -> 12345
     */
    public void setDecimalSeparatorAlwaysShown(boolean newValue) { }

    /** 
     * Standard override; no change in semantics.
     */
    public Object clone() {
        return null;
    }

    /** 
     * Overrides equals
     */
    public boolean equals(Object obj) {
        return false;
    }

    /** 
     * Overrides hashCode
     */
    public int hashCode() {
        return 0;
    }

    /** 
     * Synthesizes a pattern string that represents the current state
     * of this Format object.
     * @see #applyPattern
     */
    public String toPattern() {
        return null;
    }

    /** 
     * Synthesizes a localized pattern string that represents the current
     * state of this Format object.
     * @see #applyPattern
     */
    public String toLocalizedPattern() {
        return null;
    }

    /** 
     * Apply the given pattern to this Format object.  A pattern is a
     * short-hand specification for the various formatting properties.
     * These properties can also be changed individually through the
     * various setter methods.
     * 

     * There is no limit to integer digits are set
     * by this routine, since that is the typical end-user desire;
     * use setMaximumInteger if you want to set a real value.
     * For negative numbers, use a second pattern, separated by a semicolon
     * 
Example "#,#00.0#" -> 1,234.56
     * 
This means a minimum of 2 integer digits, 1 fraction digit, and
     * a maximum of 2 fraction digits.
     * 
Example: "#,#00.0#;(#,#00.0#)" for negatives in
     * parentheses.
     * 
In negative patterns, the minimum and maximum counts are ignored;
     * these are presumed to be set in the positive pattern.
     *
     * @exception NullPointerException if pattern is null
     * @exception IllegalArgumentException if the given pattern is invalid.
     */
    public void applyPattern(String pattern) { }

    /** 
     * Apply the given pattern to this Format object.  The pattern
     * is assumed to be in a localized notation. A pattern is a
     * short-hand specification for the various formatting properties.
     * These properties can also be changed individually through the
     * various setter methods.
     * 

     * There is no limit to integer digits are set
     * by this routine, since that is the typical end-user desire;
     * use setMaximumInteger if you want to set a real value.
     * For negative numbers, use a second pattern, separated by a semicolon
     * 
Example "#,#00.0#" -> 1,234.56
     * 
This means a minimum of 2 integer digits, 1 fraction digit, and
     * a maximum of 2 fraction digits.
     * 
Example: "#,#00.0#;(#,#00.0#)" for negatives in
     * parentheses.
     * 
In negative patterns, the minimum and maximum counts are ignored;
     * these are presumed to be set in the positive pattern.
     *
     * @exception NullPointerException if pattern is null
     * @exception IllegalArgumentException if the given pattern is invalid.
     */
    public void applyLocalizedPattern(String pattern) { }

    /** 
     * Sets the maximum number of digits allowed in the integer portion of a
     * number. This override limits the integer digit count to 309.
     * @see NumberFormat#setMaximumIntegerDigits
     */
    public void setMaximumIntegerDigits(int newValue) { }

    /** 
     * Sets the minimum number of digits allowed in the integer portion of a
     * number. This override limits the integer digit count to 309.
     * @see NumberFormat#setMinimumIntegerDigits
     */
    public void setMinimumIntegerDigits(int newValue) { }

    /** 
     * Sets the maximum number of digits allowed in the fraction portion of a
     * number. This override limits the fraction digit count to 340.
     * @see NumberFormat#setMaximumFractionDigits
     */
    public void setMaximumFractionDigits(int newValue) { }

    /** 
     * Sets the minimum number of digits allowed in the fraction portion of a
     * number. This override limits the fraction digit count to 340.
     * @see NumberFormat#setMinimumFractionDigits
     */
    public void setMinimumFractionDigits(int newValue) { }

    /** 
     * Gets the currency used by this decimal format when formatting
     * currency values.
     * The currency is obtained by calling
     * {@link DecimalFormatSymbols#getCurrency DecimalFormatSymbols.getCurrency}
     * on this number format's symbols.
     *
     * @return the currency used by this decimal format, or null
     * @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 currency is set by calling
     * {@link DecimalFormatSymbols#setCurrency DecimalFormatSymbols.setCurrency}
     * on this number format's symbols.
     *
     * @param currency the new currency to be used by this decimal format
     * @exception NullPointerException if currency is null
     * @since 1.4
     */
    public void setCurrency(Currency currency) { }

    /** 
     * First, read the default serializable fields from the stream.  Then
     * if serialVersionOnStream is less than 1, indicating that
     * the stream was written by JDK 1.1, initialize useExponentialNotation
     * to false, since it was 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 the minimum or maximum integer digit count is larger than
     * DOUBLE_INTEGER_DIGITS or if the minimum or maximum fraction
     * digit count is larger than DOUBLE_FRACTION_DIGITS, then the
     * stream data is invalid and this method throws an
     * InvalidObjectException.
     *
     * 
Stream versions older than 2 will not have the affix pattern variables
     * posPrefixPattern etc.  As a result, they will be initialized
     * to null, which means the affix strings will be taken as
     * literal values.  This is exactly what we want, since that corresponds to
     * the pre-version-2 behavior.
     */
    private void readObject(ObjectInputStream stream)
        throws IOException, ClassNotFoundException
    { }

    static final long serialVersionUID = 864413376551465018L;
}
Symbol *	Location *	Localized? *	Meaning *
`0` *	Number *	Yes *	Digit *
`#` *	Number *	Yes *	Digit, zero shows as absent *
`.` *	Number *	Yes *	Decimal separator or monetary decimal separator *
`-` *	Number *	Yes *	Minus sign *
`,` *	Number *	Yes *	Grouping separator *
`E` *	Number *	Yes *	Separates mantissa and exponent in scientific notation. * Need not be quoted in prefix or suffix. *
`;` *	Subpattern boundary *	Yes *	Separates positive and negative subpatterns *
`%` *	Prefix or suffix *	Yes *	Multiply by 100 and show as percentage *
`\u2030` *	Prefix or suffix *	Yes *	Multiply by 1000 and show as per mille *
`¤` (`\u00A4`) *	Prefix or suffix *	No *	Currency sign, replaced by currency symbol. If * doubled, replaced by international currency symbol. * If present in a pattern, the monetary decimal separator * is used instead of the decimal separator. *
`'` *	Prefix or suffix *	No *	Used to quote special characters in a prefix or suffix, * for example, `"'#'#"` formats 123 to * `"#123"`. To create a single quote * itself, use two in a row: `"# o''clock"`. *