Overrides java.lang.Object.equals.

Compares the specified object with this ListFormat for equality. Returns true if the specified object is also a ListFormat, and locale and patterns, returned from getLocale() and getPatterns() respectively, are equal.

Parameters

obj:Object

the object to be compared for equality.

Returns:boolean

true if the specified object is equal to this ListFormat

Annotations

@Override

Returns the string that consists of the input strings, concatenated with the patterns of this ListFormat.

Parameters

input:List<String>

The list of input strings to format. There should at least one String element in this list, otherwise an IllegalArgumentException is thrown.

Returns:String

the string that consists of the input strings, concatenated with the patterns of this ListFormat

Exceptions

IllegalArgumentException:

if the length of input is zero.

NullPointerException:

if input is null.

Implements abstract java.text.Format.format.

Formats an object and appends the resulting text to a given string buffer. The object should either be a List or an array of Objects.

Parameters

obj:Object

The object to format. Must be a List or an array of Object.

toAppendTo:StringBuffer

where the text is to be appended

pos:FieldPosition

Ignored. Not used in ListFormat. May be null

Returns:StringBuffer

the string buffer passed in as toAppendTo, with formatted text appended

Annotations

@Override

Exceptions

NullPointerException:

if obj or toAppendTo is null

IllegalArgumentException:

if obj is neither a List nor an array of Objects, or its length is zero.

Overrides java.text.Format.formatToCharacterIterator.

Doc from java.text.Format.formatToCharacterIterator.

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 Field. It is up to each Format implementation to define what the legal values are for each attribute in the AttributedCharacterIterator, but typically the attribute key is also used as the attribute value.

Annotations

@Override

Returns the available locales that support ListFormat.

Returns:Locale[]

the available locales that support ListFormat

Returns the ListFormat object for the default FORMAT Locale, STANDARD type, and FULL style.

Returns:ListFormat

the ListFormat object for the default FORMAT Locale, STANDARD type, and FULL style

Returns the ListFormat object for the specified Locale, Type, and Style.

Parameters

locale:Locale

Locale to be used, not null

type:ListFormat.Type

type of the ListFormat. One of STANDARD, OR, or UNIT, not null

style:ListFormat.Style

style of the ListFormat. One of FULL, SHORT, or NARROW, not null

Returns:ListFormat

the ListFormat object for the specified Locale, Type, and Style

Exceptions

NullPointerException:

if any of the arguments are null

Returns the ListFormat object for the specified patterns.

This factory returns an instance based on the customized patterns array, instead of letting the runtime provide appropriate patterns for the Locale, Type, or Style.

The patterns array should contain five String patterns, each corresponding to the Unicode LDML's listPatternPart, i.e., "start", "middle", "end", two element, and three element patterns in this order. Each pattern contains "{0}" and "{1}" (and "{2}" for the three element pattern) placeholders that are substituted with the passed input strings on formatting. If the length of the patterns array is not 5, an IllegalArgumentException is thrown.

Each pattern string is first parsed as follows. Literals in parentheses, such as "start_before", are optional:

start := (start_before){0}start_between{1}
middle := {0}middle_between{1}
end := {0}end_between{1}(end_after)
two := (two_before){0}two_between{1}(two_after)
three := (three_before){0}three_between1{1}three_between2{2}(three_after)

On formatting, the input string list with n elements substitutes above placeholders based on the number of elements:

n = 1: {0}
n = 2: parsed pattern for "two"
n = 3: parsed pattern for "three"
n > 3: (start_before){0}start_between{1}middle_between{2} ... middle_between{m}end_between{n}(end_after)

Parameters

patterns:String[]

array of patterns, not null

Returns:ListFormat

the ListFormat object for the specified patterns

Exceptions

IllegalArgumentException:

if the length patterns array is not 5, or any of start, middle, end, two, or three patterns cannot be parsed.

NullPointerException:

if patterns is null.

Returns the Locale of this ListFormat. The locale is defined by getInstance(Locale, Type, Style) or getInstance(String[]).

Returns:Locale

the Locale of this ListFormat

Returns the patterns used in this ListFormat. The patterns are defined by getInstance(Locale, Type, Style) or getInstance(String[]).

Returns:String[]

the patterns used in this ListFormat

Overrides java.lang.Object.hashCode.

Doc from java.lang.Object.hashCode.

Returns a hash code value for this object. This method is supported for the benefit of hash tables such as those provided by java.util.HashMap.

The general contract of hashCode is:

• Whenever it is invoked on the same object more than once during an execution of a Java application, the hashCode method must consistently return the same integer, provided no information used in equals comparisons on the object is modified. This integer need not remain consistent from one execution of an application to another execution of the same application.
• If two objects are equal according to the equals method, then calling the hashCode method on each of the two objects must produce the same integer result.
• It is not required that if two objects are unequal according to the equals method, then calling the hashCode method on each of the two objects must produce distinct integer results. However, the programmer should be aware that producing distinct integer results for unequal objects may improve the performance of hash tables.

Annotations

@Override

Returns the parsed list of strings from the source string. Note that format(List) and this method may not guarantee a round-trip, if the input strings contain ambiguous delimiters. For example, a two element String list "a, b,", "c" will be formatted as "a, b, and c", but may be parsed as three elements "a", "b", "c".

Parameters

source:String

the string to parse, not null.

Returns:List<String>

the parsed list of strings from the source string

Exceptions

ParseException:

if parse failed

NullPointerException:

if source is null

Implements abstract java.text.Format.parseObject.

Parses text from a string to produce a list of strings.

The method attempts to parse text starting at the index given by parsePos. If parsing succeeds, then the index of parsePos 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 object is returned. The updated parsePos can be used to indicate the starting point for the next call to parse additional text. If an error occurs, then the index of parsePos is not changed, the error index of parsePos is set to the index of the character where the error occurred, and null is returned. See the parse(String) method for more information on list parsing.

Parameters

source:String

A string, part of which should be parsed.

parsePos:ParsePosition

A ParsePosition object with index and error index information as described above.

Returns:Object

A list of string parsed from the source. In case of error, returns null.

Annotations

@Override

Exceptions

NullPointerException:

if source or parsePos is null.

IndexOutOfBoundsException:

if the starting index given by parsePos is outside source.

Overrides java.lang.Object.toString.

Returns a string identifying this ListFormat, for debugging.

Returns:String

a string identifying this ListFormat, for debugging

Annotations

@Override