SelectFormat

public class SelectFormat extends Format

SelectFormat supports the creation of internationalized messages by selecting phrases based on keywords. The pattern specifies how to map keywords to phrases and provides a default phrase. The object provided to the format method is a string that's matched against the keywords. If there is a match, the corresponding phrase is selected; otherwise, the default phrase is used.

Using SelectFormat for Gender Agreement

Note: Typically, select formatting is done via MessageFormat with a select argument type, rather than using a stand-alone SelectFormat.

The main use case for the select format is gender based inflection. When names or nouns are inserted into sentences, their gender can affect pronouns, verb forms, articles, and adjectives. Special care needs to be taken for the case where the gender cannot be determined. The impact varies between languages:

  • English has three genders, and unknown gender is handled as a special case. Names use the gender of the named person (if known), nouns referring to people use natural gender, and inanimate objects are usually neutral. The gender only affects pronouns: "he", "she", "it", "they".
  • German differs from English in that the gender of nouns is rather arbitrary, even for nouns referring to people ("Mädchen", girl, is neutral). The gender affects pronouns ("er", "sie", "es"), articles ("der", "die", "das"), and adjective forms ("guter Mann", "gute Frau", "gutes Mädchen").
  • French has only two genders; as in German the gender of nouns is rather arbitrary - for sun and moon, the genders are the opposite of those in German. The gender affects pronouns ("il", "elle"), articles ("le", "la"), adjective forms ("bon", "bonne"), and sometimes verb forms ("allé", "allée").
  • Polish distinguishes five genders (or noun classes), human masculine, animate non-human masculine, inanimate masculine, feminine, and neuter.

Some other languages have noun classes that are not related to gender, but similar in grammatical use. Some African languages have around 20 noun classes.

Note:For the gender of a person in a given sentence, we usually need to distinguish only between female, male and other/unknown.

To enable localizers to create sentence patterns that take their language's gender dependencies into consideration, software has to provide information about the gender associated with a noun or name to MessageFormat. Two main cases can be distinguished:

  • For people, natural gender information should be maintained for each person. Keywords like "male", "female", "mixed" (for groups of people) and "unknown" could be used.
  • For nouns, grammatical gender information should be maintained for each noun and per language, e.g., in resource bundles. The keywords "masculine", "feminine", and "neuter" are commonly used, but some languages may require other keywords.

The resulting keyword is provided to MessageFormat as a parameter separate from the name or noun it's associated with. For example, to generate a message such as "Jean went to Paris", three separate arguments would be provided: The name of the person as argument 0, the gender of the person as argument 1, and the name of the city as argument 2. The sentence pattern for English, where the gender of the person has no impact on this simple sentence, would not refer to argument 1 at all:

{0} went to {2}.

Note: The entire sentence should be included (and partially repeated) inside each phrase. Otherwise translators would have to be trained on how to move bits of the sentence in and out of the select argument of a message. (The examples below do not follow this recommendation!)

The sentence pattern for French, where the gender of the person affects the form of the participle, uses a select format based on argument 1:

{0} est {1, select, female {allée} other {allé}} à {2}.

Patterns can be nested, so that it's possible to handle interactions of number and gender where necessary. For example, if the above sentence should allow for the names of several people to be inserted, the following sentence pattern can be used (with argument 0 the list of people's names, argument 1 the number of people, argument 2 their combined gender, and argument 3 the city name):

{0} {1, plural, 
 one {est {2, select, female {allée} other  {allé}}}
 other {sont {2, select, female {allées} other {allés}}}
 }à {3}.

Patterns and Their Interpretation

The SelectFormat pattern string defines the phrase output for each user-defined keyword. The pattern is a sequence of (keyword, message) pairs. A keyword is a "pattern identifier": [^[[:Pattern_Syntax:][:Pattern_White_Space:]]]+

Each message is a MessageFormat pattern string enclosed in {curly braces}.

You always have to define a phrase for the default keyword other; this phrase is returned when the keyword provided to the format method matches no other keyword. If a pattern does not provide a phrase for other, the method it's provided to returns the error U_DEFAULT_KEYWORD_MISSING.
Pattern_White_Space between keywords and messages is ignored. Pattern_White_Space within a message is preserved and output.

Example:
 MessageFormat msgFmt = new MessageFormat("{0} est " +
     "{1, select, female {allée} other {allé}} à Paris.",
     new ULocale("fr"));
 Object args[] = {"Kirti","female"};
 System.out.println(msgFmt.format(args));
 

Produces the output:
Kirti est allée à Paris.

Public Constructor Summary

SelectFormat(String pattern)
Creates a new SelectFormat for a given pattern string.

Public Method Summary

void
applyPattern(String pattern)
Sets the pattern used by this select format.
boolean
equals(Object obj)
Compares this instance with the specified object and indicates if they are equal.
StringBuffer
format(Object keyword, StringBuffer toAppendTo, FieldPosition pos)
Selects the phrase for the given keyword.
final String
format(String keyword)
Selects the phrase for the given keyword.
int
hashCode()
Returns an integer hash code for this object.
Object
parseObject(String source, ParsePosition pos)
This method is not supported by SelectFormat.
String
toPattern()
Returns the pattern for this SelectFormat
String
toString()
Returns a string containing a concise, human-readable description of this object.

Inherited Method Summary

Public Constructors

public SelectFormat (String pattern)

Creates a new SelectFormat for a given pattern string.

Parameters
pattern the pattern for this SelectFormat.

Public Methods

public void applyPattern (String pattern)

Sets the pattern used by this select format. Patterns and their interpretation are specified in the class description.

Parameters
pattern the pattern for this select format.
Throws
IllegalArgumentException when the pattern is not a valid select format pattern.

public boolean equals (Object obj)

Compares this instance with the specified object and indicates if they are equal. In order to be equal, o must represent the same object as this instance using a class-specific comparison. The general contract is that this comparison should be reflexive, symmetric, and transitive. Also, no object reference other than null is equal to null.

The default implementation returns true only if this == o. See Writing a correct equals method if you intend implementing your own equals method.

The general contract for the equals and hashCode() methods is that if equals returns true for any two objects, then hashCode() must return the same value for these objects. This means that subclasses of Object usually override either both methods or neither of them.

Parameters
obj the object to compare this instance with.
Returns
  • true if the specified object is equal to this Object; false otherwise.

public StringBuffer format (Object keyword, StringBuffer toAppendTo, FieldPosition pos)

Selects the phrase for the given keyword. and appends the formatted message to the given StringBuffer.

Parameters
keyword a phrase selection keyword.
toAppendTo the selected phrase will be appended to this StringBuffer.
pos will be ignored by this method.
Returns
  • the string buffer passed in as toAppendTo, with formatted text appended.
Throws
IllegalArgumentException when the given keyword is not a String or not a "pattern identifier"

public final String format (String keyword)

Selects the phrase for the given keyword.

Parameters
keyword a phrase selection keyword.
Returns
  • the string containing the formatted select message.
Throws
IllegalArgumentException when the given keyword is not a "pattern identifier"

public int hashCode ()

Returns an integer hash code for this object. By contract, any two objects for which equals(Object) returns true must return the same hash code value. This means that subclasses of Object usually override both methods or neither method.

Note that hash values must not change over time unless information used in equals comparisons also changes.

See Writing a correct hashCode method if you intend implementing your own hashCode method.

Returns
  • this object's hash code.

public Object parseObject (String source, ParsePosition pos)

This method is not supported by SelectFormat.

Parameters
source the string to be parsed.
pos defines the position where parsing is to begin, and upon return, the position where parsing left off. If the position has not changed upon return, then parsing failed.
Returns
  • nothing because this method is not supported.
Throws
UnsupportedOperationException thrown always.

public String toPattern ()

Returns the pattern for this SelectFormat

Returns
  • the pattern string

public String toString ()

Returns a string containing a concise, human-readable description of this object. Subclasses are encouraged to override this method and provide an implementation that takes into account the object's type and data. The default implementation is equivalent to the following expression:

   getClass().getName() + '@' + Integer.toHexString(hashCode())

See Writing a useful toString method if you intend implementing your own toString method.

Returns
  • a printable representation of this object.