W3cubDocs

/OpenJDK 25

Class CompactNumberFormat

java.lang.Object
java.text.Format
java.text.NumberFormat
java.text.CompactNumberFormat
All Implemented Interfaces:
Serializable, Cloneable
public final class CompactNumberFormat extends NumberFormat

CompactNumberFormat is a concrete subclass of NumberFormat that formats a decimal number in a localized compact form. Compact number formatting is designed for an environment with limited space. For example, displaying the formatted number 7M instead of 7,000,000.00 in the US locale. The CompactNumberFormat class is defined by LDML's specification for Compact Number Formats.

Getting a CompactNumberFormat

To get a compact number format, use one of the ways listed below.

If a standard compact format for a given locale and style is desired, it is recommended to use one of the NumberFormat factory methods listed above. To use an instance method defined by CompactNumberFormat, the NumberFormat returned by these factory methods should be type checked before converted to CompactNumberFormat. If the installed locale-sensitive service implementation does not support the given Locale, the parent locale chain will be looked up, and a Locale used that is supported.

Style

When using NumberFormat.getCompactNumberInstance(Locale, Style), a compact form can be retrieved with either a SHORT or LONG style. For example, a SHORT style compact number instance in the US locale formats 10000 as "10K". However, a LONG style instance in the same locale formats 10000 as "10 thousand".

Using CompactNumberFormat

The following is an example of formatting and parsing in a localized manner, 
NumberFormat compactFormat = NumberFormat.getCompactNumberInstance(Locale.US, NumberFormat.Style.SHORT);
compactFormat.format(1000); // returns "1K"
compactFormat.parse("1K"); // returns 1000

Formatting

The default formatting behavior returns a formatted string with no fractional digits, however users can use the setMinimumFractionDigits(int) method to include the fractional part. The number 1000.0 or 1000 is formatted as "1K" not "1.00K" (in the US locale). For this reason, the patterns provided for formatting contain only the minimum integer digits, prefix and/or suffix, but no fractional part. For example, patterns used are {"", "", "", 0K, 00K, ...}. If the pattern selected for formatting a number is "0" (special pattern), either explicit or defaulted, then the general number formatting provided by DecimalFormat for the specified locale is used.

Rounding

CompactNumberFormat provides rounding modes defined in RoundingMode for formatting. By default, it uses RoundingMode.HALF_EVEN.

Parsing

The default parsing behavior does not allow a grouping separator until grouping used is set to true by using setGroupingUsed(boolean). The parsing of the fractional part depends on the isParseIntegerOnly(). For example, if the parse integer only is set to true, then the fractional part is skipped.

Compact Number Patterns

The compactPatterns in CompactNumberFormat(decimalPattern, symbols, compactPatterns) are represented as a series of strings, where each string is a pattern that is used to format a range of numbers.

An example of the SHORT styled compact number patterns for the US locale is {"", "", "", "0K", "00K", "000K", "0M", "00M", "000M", "0B", "00B", "000B", "0T", "00T", "000T"}, ranging from 100 to 1014. There can be any number of patterns and they are strictly index based starting from the range 100. For example, in the above patterns, the pattern at index 3 ("0K") is used for formatting a number in the range: 1000 <= number < 10000, index 4 ("00K") for formatting a number the range: 10000 <= number < 100000, and so forth.

In most locales, patterns with the range 100-102 are empty strings, which implicitly means a special pattern "0". A special pattern "0" is used for any range which does not contain a compact pattern. This special pattern can appear explicitly for any specific range, or considered as a default pattern for an empty string.

Negative Subpatterns

A compact pattern contains a positive and negative subpattern separated by a subpattern boundary character ';', for example, "0K;-0K". Each subpattern has a prefix, minimum integer digits, and suffix. The negative subpattern is optional, if absent, then the positive subpattern prefixed with the minus sign '-' (U+002D HYPHEN-MINUS) is used as the negative subpattern. That is, "0K" alone is equivalent to "0K;-0K". If there is an explicit negative subpattern, it serves only to specify the negative prefix and suffix. The number of minimum integer digits, and other characteristics are all the same as the positive pattern. That means that "0K;-00K" produces precisely the same behavior as "0K;-0K".

Escaping Special Characters

Many characters in a compact 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. These characters must be quoted using single quotes ' (U+0027) unless noted otherwise, if they are to appear in the prefix or suffix as literals. For example, 0क'.'.

Plurals

CompactNumberFormat support patterns for both singular and plural compact forms. For the plural form, the Pattern should consist of PluralPattern(s) separated by a space ' ' (U+0020) that are enumerated within a pair of curly brackets '{' (U+007B) and '}' (U+007D). In this format, each PluralPattern consists of its count, followed by a single colon ':' (U+003A) and a SimplePattern. As a space is reserved for separating subsequent PluralPatterns, it must be quoted to be used literally in either the prefix or suffix.

For example, while the pattern representing millions (106 ) in the US locale can be specified as the SimplePattern: "0 Million", for the German locale it can be specified as the PluralPattern: "{one:0' 'Million other:0' 'Millionen}".

A compact pattern has the following syntax, with count following LDML's Language Plural Rules: 

Pattern:
        SimplePattern
        '{' PluralPattern [' ' PluralPattern]optional '}'
SimplePattern:
        PositivePattern
        PositivePattern [; NegativePattern]optional
PluralPattern:
        Count:SimplePattern
Count:
        "zero" / "one" / "two" / "few" / "many" / "other"
PositivePattern:
        Prefixoptional MinimumInteger Suffixoptional
NegativePattern:
       Prefixoptional MinimumInteger Suffixoptional
Prefix:
     Any characters except the special pattern characters
Suffix:
     Any characters except the special pattern characters
MinimumInteger:
     0
     0 MinimumInteger
Since:
12
External Specifications
See Also:

Nested Class Summary

Nested classes/interfaces declared in class NumberFormat

NumberFormat.Field, NumberFormat.Style

Field Summary

Fields declared in class NumberFormat

FRACTION_FIELD, INTEGER_FIELD

Constructor Summary

Constructor Description
CompactNumberFormat(String decimalPattern, DecimalFormatSymbols symbols, String[] compactPatterns)
Creates a CompactNumberFormat using the given decimal pattern, decimal format symbols and compact patterns.
CompactNumberFormat(String decimalPattern, DecimalFormatSymbols symbols, String[] compactPatterns, String pluralRules)
Creates a CompactNumberFormat using the given decimal pattern, decimal format symbols, compact patterns, and plural rules.

Method Summary

Modifier and Type Method Description
CompactNumberFormat clone()
Creates and returns a copy of this CompactNumberFormat instance.
boolean equals(Object obj)
Compares the specified object with this CompactNumberFormat for equality.
StringBuffer format(double number, StringBuffer result, FieldPosition fieldPosition)
Formats a double to produce a string representing its compact form.
StringBuffer format(long number, StringBuffer result, FieldPosition fieldPosition)
Formats a long to produce a string representing its compact form.
final StringBuffer format(Object number, StringBuffer toAppendTo, FieldPosition fieldPosition)
Formats a number to produce a string representing its compact form.
AttributedCharacterIterator formatToCharacterIterator(Object obj)
Formats an Object producing an AttributedCharacterIterator.
int getGroupingSize()
Returns the grouping size.
RoundingMode getRoundingMode()
Gets the RoundingMode used in this CompactNumberFormat.
int hashCode()
Returns the hash code for this CompactNumberFormat.
boolean isGroupingUsed()
Returns true if grouping is used in this format.
boolean isParseBigDecimal()
Returns whether the parse(String, ParsePosition) method returns BigDecimal.
boolean isParseIntegerOnly()
Returns true if this format parses only an integer from the number component of a compact number.
boolean isStrict()
Returns true if this format will parse numbers strictly; false otherwise.
Number parse(String text, ParsePosition pos)
Parses text from the beginning of the given string to produce a Number.
void setGroupingSize(int newValue)
Sets the grouping size.
void setGroupingUsed(boolean newValue)
Sets whether or not grouping will be used in this format.
void setMaximumFractionDigits(int newValue)
Sets the maximum number of digits allowed in the fraction portion of a number during formatting.
void setMaximumIntegerDigits(int newValue)
Sets the maximum number of digits allowed in the integer portion of a number during formatting.
void setMinimumFractionDigits(int newValue)
Sets the minimum number of digits allowed in the fraction portion of a number during formatting.
void setMinimumIntegerDigits(int newValue)
Sets the minimum number of digits allowed in the integer portion of a number during formatting.
void setParseBigDecimal(boolean newValue)
Sets whether the parse(String, ParsePosition) method returns BigDecimal.
void setParseIntegerOnly(boolean value)
Sets whether or not this format parses only an integer from the number component of a compact number.
void setRoundingMode(RoundingMode roundingMode)
Sets the RoundingMode used in this CompactNumberFormat.
void setStrict(boolean strict)
Change the leniency value for parsing.
String toString()
Returns a string identifying this CompactNumberFormat, for debugging.

Methods declared in class NumberFormat

format, format, getAvailableLocales, getCompactNumberInstance, getCompactNumberInstance, getCurrency, getCurrencyInstance, getCurrencyInstance, getInstance, getInstance, getIntegerInstance, getIntegerInstance, getMaximumFractionDigits, getMaximumIntegerDigits, getMinimumFractionDigits, getMinimumIntegerDigits, getNumberInstance, getNumberInstance, getPercentInstance, getPercentInstance, parse, parseObject, setCurrency

Methods declared in class Format

format, parseObject

Methods declared in class Object

finalize, getClass, notify, notifyAll, wait, wait, wait

Constructor Details

CompactNumberFormat

public CompactNumberFormat(String decimalPattern, DecimalFormatSymbols symbols, String[] compactPatterns)
Creates a CompactNumberFormat using the given decimal pattern, decimal format symbols and compact patterns. To obtain the instance of CompactNumberFormat with the standard compact patterns for a Locale and Style, it is recommended to use the factory methods given by NumberFormat for compact number formatting.

Below is an example of using the constructor, 

String[] compactPatterns = {"", "", "", "a lot"};
NumberFormat fmt = new CompactNumberFormat("00", DecimalFormatSymbols.getInstance(Locale.US), compactPatterns);
fmt.format(1); // returns "01"
fmt.format(1000); // returns "a lot"
Parameters:
decimalPattern - a decimal pattern for general number formatting
symbols - the set of symbols to be used
compactPatterns - an array of compact number patterns
Throws:
NullPointerException - if any of the given arguments is null
IllegalArgumentException - if the given decimalPattern or the compactPatterns array contains an invalid pattern or if a null appears in the array of compact patterns
See Also:

CompactNumberFormat

public CompactNumberFormat(String decimalPattern, DecimalFormatSymbols symbols, String[] compactPatterns, String pluralRules)
Creates a CompactNumberFormat using the given decimal pattern, decimal format symbols, compact patterns, and plural rules. To obtain the instance of CompactNumberFormat with the standard compact patterns for a Locale, Style, and pluralRules, it is recommended to use the factory methods given by NumberFormat for compact number formatting. For example, NumberFormat.getCompactNumberInstance(Locale, Style).
Parameters:
decimalPattern - a decimal pattern for general number formatting
symbols - the set of symbols to be used
compactPatterns - an array of compact number patterns
pluralRules - a String designating plural rules which associate the Count keyword, such as "one", and the actual integer number. Its syntax is defined in Unicode Consortium's Plural rules syntax
Throws:
NullPointerException - if any of the given arguments is null
IllegalArgumentException - if the given decimalPattern, the compactPatterns array contains an invalid pattern, a null appears in the array of compact patterns, or if the given pluralRules contains an invalid syntax
Since:
14
External Specifications
See Also:

Method Details

format

public final StringBuffer format(Object number, StringBuffer toAppendTo, FieldPosition fieldPosition)
Formats a number to produce a string representing its compact form. The number can be of any subclass of Number.
Overrides:
format in class NumberFormat
Parameters:
number - the number to format
toAppendTo - the StringBuffer to which the formatted text is to be appended
fieldPosition - keeps track on the position of the field within the returned string. For example, for formatting a number 123456789 in the US locale, if the given fieldPosition is NumberFormat.INTEGER_FIELD, the begin index and end index of fieldPosition will be set to 0 and 3, respectively for the output string 123M. Similarly, positions of the prefix and the suffix fields can be obtained using NumberFormat.Field.PREFIX and NumberFormat.Field.SUFFIX respectively.
Returns:
the StringBuffer passed in as toAppendTo
Throws:
IllegalArgumentException - if number is null or not an instance of Number
NullPointerException - if toAppendTo or fieldPosition is null
ArithmeticException - if rounding is needed with rounding mode being set to RoundingMode.UNNECESSARY
See Also:

format

public StringBuffer format(double number, StringBuffer result, FieldPosition fieldPosition)
Formats a double to produce a string representing its compact form.
Specified by:
format in class NumberFormat
Parameters:
number - the double number to format
result - where the text is to be appended
fieldPosition - keeps track on the position of the field within the returned string. For example, to format a number 1234567.89 in the US locale if the given fieldPosition is NumberFormat.INTEGER_FIELD, the begin index and end index of fieldPosition will be set to 0 and 1, respectively for the output string 1M. Similarly, positions of the prefix and the suffix fields can be obtained using NumberFormat.Field.PREFIX and NumberFormat.Field.SUFFIX respectively.
Returns:
the StringBuffer passed in as result
Throws:
NullPointerException - if result or fieldPosition is null
ArithmeticException - if rounding is needed with rounding mode being set to RoundingMode.UNNECESSARY
See Also:

format

public StringBuffer format(long number, StringBuffer result, FieldPosition fieldPosition)
Formats a long to produce a string representing its compact form.
Specified by:
format in class NumberFormat
Parameters:
number - the long number to format
result - where the text is to be appended
fieldPosition - keeps track on the position of the field within the returned string. For example, to format a number 123456789 in the US locale, if the given fieldPosition is NumberFormat.INTEGER_FIELD, the begin index and end index of fieldPosition will be set to 0 and 3, respectively for the output string 123M. Similarly, positions of the prefix and the suffix fields can be obtained using NumberFormat.Field.PREFIX and NumberFormat.Field.SUFFIX respectively.
Returns:
the StringBuffer passed in as result
Throws:
NullPointerException - if result or fieldPosition is null
ArithmeticException - if rounding is needed with rounding mode being set to RoundingMode.UNNECESSARY
See Also:

formatToCharacterIterator

public AttributedCharacterIterator formatToCharacterIterator(Object obj)
Formats an Object producing an AttributedCharacterIterator. The returned AttributedCharacterIterator can be used 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. The prefix and the suffix parts of the returned iterator (if present) are represented by the attributes NumberFormat.Field.PREFIX and NumberFormat.Field.SUFFIX respectively.

Overrides:
formatToCharacterIterator in class Format
Parameters:
obj - The object to format
Returns:
an AttributedCharacterIterator describing the formatted value
Throws:
NullPointerException - if obj is null
IllegalArgumentException - when the Format cannot format the given object
ArithmeticException - if rounding is needed with rounding mode being set to RoundingMode.UNNECESSARY

parse

public Number parse(String text, ParsePosition pos)
Parses text from the beginning of the given string to produce a Number.

This method attempts to parse text starting at the index given by the ParsePosition. If parsing succeeds, then the index of the ParsePosition 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 ParsePosition can be used to indicate the starting point for the next call to this method. If an error occurs, then the index of the ParsePosition is not changed, the error index of the ParsePosition is set to the index of the character where the error occurred, and null is returned.

This method will return a Long if possible (e.g., within the range [Long.MIN_VALUE, Long.MAX_VALUE] and with no decimals), otherwise a Double.

The returned value is the numeric part in the given text multiplied by the numeric equivalent of the affix attached (For example, "K" = 1000 in US locale).

A CompactNumberFormat can match the default prefix/suffix to a compact prefix/suffix interchangeably.

Parsing can be done in either a strict or lenient manner, by default it is lenient.

Parsing fails when lenient, if the prefix and/or suffix are non-empty and cannot be found due to parsing ending early, or the first character after the prefix cannot be parsed.

Parsing fails when strict, if in text,

  • The default or a compact prefix is not found. For example, the Locale.US currency format prefix: "$"
  • The default or a compact suffix is not found. For example, a Locale.US NumberFormat.Style.SHORT compact suffix: "K"
  • isGroupingUsed() returns false, and the grouping symbol is found
  • isGroupingUsed() returns true, and getGroupingSize() is not adhered to
  • isParseIntegerOnly() returns true, and the decimal separator is found
  • isGroupingUsed() returns true and isParseIntegerOnly() returns false, and the grouping symbol occurs after the decimal separator
  • Any other characters are found, that are not the expected symbols, and are not digits that occur within the numerical portion

The subclass returned depends on the value of isParseBigDecimal().

  • If isParseBigDecimal() is false (the default), most integer values are returned as Long objects, no matter how they are written: "17K" and "17.000K" both parse to Long.valueOf(17000). If the value cannot fit into Long, then the result is returned as Double. This includes values with a fractional part, infinite values, NaN, and the value -0.0.

    Callers may use the Number methods doubleValue, longValue, etc., to obtain the type they want.

  • If isParseBigDecimal() is true, values are returned as BigDecimal objects. The special cases negative and positive infinity and NaN are returned as Double instances holding the values of the corresponding Double constants.

CompactNumberFormat parses all Unicode characters that represent decimal digits, as defined by Character.digit(). In addition, CompactNumberFormat also recognizes as digits the ten consecutive characters starting with the localized zero digit defined in the DecimalFormatSymbols object.

CompactNumberFormat parse does not allow parsing scientific notations. For example, parsing a string "1.05E4K" in US locale breaks at character 'E' and returns 1.05.

Specified by:
parse in class NumberFormat
Parameters:
text - the string to be parsed
pos - a ParsePosition object with index and error index information as described above
Returns:
the parsed value, or null if the parse fails
Throws:
NullPointerException - if text or pos is null
See Also:

setMaximumIntegerDigits

public void setMaximumIntegerDigits(int newValue)
Sets the maximum number of digits allowed in the integer portion of a number during formatting. 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. Negative input values are replaced with 0.

The maximum allowed integer range is 309, if the newValue > 309, then the maximum integer digits count is set to 309.

Overrides:
setMaximumIntegerDigits in class NumberFormat
Parameters:
newValue - the maximum number of integer digits to be shown.
See Also:

setMinimumIntegerDigits

public void setMinimumIntegerDigits(int newValue)
Sets the minimum number of digits allowed in the integer portion of a number during formatting. 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. Negative input values are replaced with 0.

The maximum allowed integer range is 309, if the newValue > 309, then the minimum integer digits count is set to 309.

Overrides:
setMinimumIntegerDigits in class NumberFormat
Parameters:
newValue - the minimum number of integer digits to be shown.
See Also:

setMinimumFractionDigits

public void setMinimumFractionDigits(int newValue)
Sets the minimum number of digits allowed in the fraction portion of a number during formatting. minimumFractionDigits must be ≤ maximumFractionDigits. If the new value for minimumFractionDigits exceeds the current value of maximumFractionDigits, then maximumFractionDigits will also be set to the new value. Negative input values are replaced with 0.

The maximum allowed fraction range is 340, if the newValue > 340, then the minimum fraction digits count is set to 340.

Overrides:
setMinimumFractionDigits in class NumberFormat
Parameters:
newValue - the minimum number of fraction digits to be shown.
See Also:

setMaximumFractionDigits

public void setMaximumFractionDigits(int newValue)
Sets the maximum number of digits allowed in the fraction portion of a number during formatting. 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. Negative input values are replaced with 0.

The maximum allowed fraction range is 340, if the newValue > 340, then the maximum fraction digits count is set to 340.

Overrides:
setMaximumFractionDigits in class NumberFormat
Parameters:
newValue - the maximum number of fraction digits to be shown.
See Also:

getRoundingMode

public RoundingMode getRoundingMode()
Gets the RoundingMode used in this CompactNumberFormat.
Overrides:
getRoundingMode in class NumberFormat
Returns:
the RoundingMode used for this CompactNumberFormat
See Also:

setRoundingMode

public void setRoundingMode(RoundingMode roundingMode)
Sets the RoundingMode used in this CompactNumberFormat.
Overrides:
setRoundingMode in class NumberFormat
Parameters:
roundingMode - the RoundingMode to be used
Throws:
NullPointerException - if roundingMode is null
See Also:

getGroupingSize

public int getGroupingSize()
Returns the grouping size. Grouping size is the number of digits between grouping separators in the integer portion of a number. For example, in the compact number "12,347 trillion" for the US locale, the grouping size is 3.
Returns:
the grouping size
See Also:

setGroupingSize

public void setGroupingSize(int newValue)
Sets the grouping size. Grouping size is the number of digits between grouping separators in the integer portion of a number. For example, in the compact number "12,347 trillion" for the US locale, the grouping size is 3. The grouping size must be greater than or equal to zero and less than or equal to 127.
Parameters:
newValue - the new grouping size
Throws:
IllegalArgumentException - if newValue is negative or larger than 127
See Also:

isGroupingUsed

public boolean isGroupingUsed()
Returns true if grouping is used in this format. For example, with grouping on and grouping size set to 3, the number 12346567890987654 can be formatted as "12,347 trillion" in the US locale. The grouping separator is locale dependent.
Overrides:
isGroupingUsed in class NumberFormat
Returns:
true if grouping is used; false otherwise
See Also:

setGroupingUsed

public void setGroupingUsed(boolean newValue)
Sets whether or not grouping will be used in this format.
Overrides:
setGroupingUsed in class NumberFormat
Parameters:
newValue - true if grouping is used; false otherwise
See Also:

isParseIntegerOnly

public boolean isParseIntegerOnly()
Returns true if this format parses only an integer from the number component of a compact number. Parsing an integer means that only an integer is considered from the number component, prefix/suffix is still considered to compute the resulting output. For example, in the US locale, if this method returns true, the string "1234.78 thousand" would be parsed as the value 1234000 (1234 (integer part) * 1000 (thousand)) and the fractional part would be skipped. The exact format accepted by the parse operation is locale dependent.
Overrides:
isParseIntegerOnly in class NumberFormat
Implementation Requirements:
This implementation does not set the ParsePosition index to the position of the decimal symbol, but rather the end of the string.
Returns:
true if compact numbers should be parsed as integers only; false otherwise

setParseIntegerOnly

public void setParseIntegerOnly(boolean value)
Sets whether or not this format parses only an integer from the number component of a compact number.
Overrides:
setParseIntegerOnly in class NumberFormat
Parameters:
value - true if compact numbers should be parsed as integers only; false otherwise
See Also:

isStrict

public boolean isStrict()
Returns true if this format will parse numbers strictly; false otherwise.
Overrides:
isStrict in class NumberFormat
Returns:
true if this format will parse numbers strictly; false otherwise
Since:
23
See Also:

setStrict

public void setStrict(boolean strict)
Change the leniency value for parsing. Parsing can either be strict or lenient, by default it is lenient.
Overrides:
setStrict in class NumberFormat
Parameters:
strict - true if parsing should be done strictly; false otherwise
Since:
23
See Also:

isParseBigDecimal

public boolean isParseBigDecimal()
Returns whether the parse(String, ParsePosition) method returns BigDecimal. The default value is false.
Returns:
true if the parse method returns BigDecimal; false otherwise
See Also:

setParseBigDecimal

public void setParseBigDecimal(boolean newValue)
Sets whether the parse(String, ParsePosition) method returns BigDecimal.
Parameters:
newValue - true if the parse method returns BigDecimal; false otherwise
See Also:

equals

public boolean equals(Object obj)
Compares the specified object with this CompactNumberFormat for equality. Returns true if the object is also a CompactNumberFormat and the two formats would format any value the same.
Overrides:
equals in class NumberFormat
Implementation Requirements:
This method performs an equality check with a notion of class identity based on getClass(), rather than instanceof. Therefore, in the equals methods in subclasses, no instance of this class should compare as equal to an instance of a subclass.
Parameters:
obj - the object to compare with
Returns:
true if this is equal to the other CompactNumberFormat
See Also:

hashCode

public int hashCode()
Returns the hash code for this CompactNumberFormat.
Overrides:
hashCode in class NumberFormat
Implementation Requirements:
Non-transient instance fields of this class are used to calculate a hash code value which adheres to the contract defined in Objects.hashCode(Object)
Returns:
the hash code for this CompactNumberFormat
See Also:

toString

public String toString()
Returns a string identifying this CompactNumberFormat, for debugging.
Overrides:
toString in class Object
Returns:
a string identifying this CompactNumberFormat, for debugging

clone

public CompactNumberFormat clone()
Creates and returns a copy of this CompactNumberFormat instance.
Overrides:
clone in class NumberFormat
Returns:
a clone of this instance
See Also:

© 1993, 2025, Oracle and/or its affiliates. All rights reserved.
Documentation extracted from Debian's OpenJDK Development Kit package.
Licensed under the GNU General Public License, version 2, with the Classpath Exception.
Various third party code in OpenJDK is licensed under different licenses (see Debian package).
Java and OpenJDK are trademarks or registered trademarks of Oracle and/or its affiliates.
https://docs.oracle.com/en/java/javase/25/docs/api/java.base/java/text/CompactNumberFormat.html