Class java.text.MessageFormat
All Packages  Class Hierarchy  This Package  Previous  Next  Index

Class java.text.MessageFormat

Object
   |
   +----Format
           |
           +----java.text.MessageFormat

public class MessageFormat
extends Format
MessageFormat provides a means to produce concatenated messages in language-neutral way. Use this to construct messages displayed for end users.

MessageFormat takes a set of objects, formats them, then inserts the formatted strings into the pattern at the appropriate places.

Note: MessageFormat differs from the other Format classes in that you create a MessageFormat object with one of its constructors (not with a getInstance style factory method). The factory methods aren't necessary because MessageFormat doesn't require any complex setup for a given locale. In fact, MessageFormat doesn't implement any locale specific behavior at all. It just needs to be set up on a sentence by sentence basis.

Here are some examples of usage:

 Object[] arguments = {
     new Integer(7),
     new Date(System.currentTimeMillis()),
     "a disturbance in the Force"
 };

 String result = MessageFormat.format(
     "At {1,time} on {1,date}, there was {2} on planet {0,number,integer}.",
     arguments);

 : At 12:30 PM on Jul 3, 2053, there was a disturbance
           in the Force on planet 7.

 
Typically, the message format will come from resources, and the arguments will be dynamically set at runtime.

Example 2:

 Object[] testArgs = {new Long(3), "MyDisk"};

 MessageFormat form = new MessageFormat(
     "The disk \"{1}\" contains {0} file(s).");

 System.out.println(form.format(testArgs));

 // output, with different testArgs
 : The disk "MyDisk" contains 0 file(s).
 : The disk "MyDisk" contains 1 file(s).
 : The disk "MyDisk" contains 1,273 file(s).
 

The pattern is of the form:

 messageFormatPattern := string ( "{" messageFormatElement "}" string )*

 messageFormatElement := argument { "," elementFormat }

 elementFormat := "time" { "," datetimeStyle }
                | "date" { "," datetimeStyle }
                | "number" { "," numberStyle }
                | "choice" { "," choiceStyle }

 datetimeStyle := "short"
                  | "medium"
                  | "long"
                  | "full"
                  | dateFormatPattern

 numberStyle := "currency"
               | "percent"
               | "integer"
               | numberFormatPattern

 choiceStyle := choiceFormatPattern
 
If there is no elementFormat, then the argument must be a string, which is substituted. If there is no dateTimeStyle or numberStyle, then the default format is used (for example, NumberFormat.getInstance, DateFormat.getTimeInstance, or DateFormat.getInstance).

In strings, single quotes can be used to quote the "{" (curly brace) if necessary. A real single quote is represented by ''. Inside a messageFormatElement, quotes are not removed. For example, {1,number,$'#',##} will produce a number format with the pound-sign quoted, with a result such as: "$#31,45".

If a pattern is used, then unquoted braces in the pattern, if any, must match: that is, "ab {0} de" and "ab '}' de" are ok, but "ab {0'}' de" and "ab } de" are not.

The argument is a number from 0 to 9, which corresponds to the arguments presented in an array to be formatted.

It is ok to have unused arguments in the array. With missing arguments or arguments that are not of the right class for the specified format, a ParseException is thrown. First, format checks to see if a Format object has been specified for the argument with the setFormats method. If so, then format uses that Format object to format the argument. Otherwise, the argument is formatted based on the object's type. If the argument is a Number, then format uses NumberFormat.getInstance to format the argument; if the argument is a Date, then format uses DateFormat.getDateTimeInstance to format the argument. Otherwise, it uses the toString method.

For more sophisticated patterns, you can use a ChoiceFormat to get output such as:

 MessageFormat form = new MessageFormat("The disk \"{1}\" contains {0}.");
 double[] filelimits = {0,1,2};
 String[] filepart = {"no files","one file","{0,number} files"};
 ChoiceFormat fileform = new ChoiceFormat(filelimits, filepart);
 form.setFormat(1,fileform); // NOT zero, see below

 Object[] testArgs = {new Long(12373), "MyDisk"};

 System.out.println(form.format(testArgs));

 // output, with different testArgs
 output: The disk "MyDisk" contains no files.
 output: The disk "MyDisk" contains one file.
 output: The disk "MyDisk" contains 1,273 files.
 
You can either do this programmatically, as in the above example, or by using a pattern (see ChoiceFormat for more information) as in:
 form.applyPattern(
    "There {0,choice,0#are no files|1#is one file|1#are {0,number,integer} files}.");
 

Note: As we see above, the string produced by a ChoiceFormat in MessageFormat is treated specially; occurances of '{' are used to indicated subformats, and cause recursion. If you create both a MessageFormat and ChoiceFormat programmatically (instead of using the string patterns), then be careful not to produce a format that recurses on itself, which will cause an infinite loop.

Note: formats are numbered by order of variable in the string. This is not the same as the argument numbering! For example: with "abc{2}def{3}ghi{0}...",

You can use setLocale followed by applyPattern (and then possibly setFormat) to re-initialize a MessageFormat with a different locale.

Version:
1.15 29 Jan 1997
Author:
Mark Davis
See Also:
Locale, Format, NumberFormat, DecimalFormat, ChoiceFormat

Constructor Index

 o java.text.MessageFormat(String)
Constructs with the specified pattern.

Method Index

 o applyPattern(String)
Sets the pattern.
 o clone()
Overrides Cloneable
 o equals(Object)
Equality comparision between two message format objects
 o format(Object[], StringBuffer, FieldPosition)
Returns pattern with formatted objects.
 o format(String, Object[])
Convenience routine.
 o format(Object, StringBuffer, FieldPosition)
Formats an object to produce a string.
 o getFormats()
Gets formats that were set with setFormats.
 o getLocale()
Gets the locale.
 o hashCode()
Generates a hash code for the message format object.
 o parse(String, ParsePosition)
Parses the string.
 o parse(String)
Parses the string.
 o parseObject(String, ParsePosition)
Parses the string.
 o setFormat(int, Format)
Sets formats individually to use on parameters.
 o setFormats(Format[])
Sets formats to use on parameters.
 o setLocale(Locale)
Constructs with the specified pattern and formats for the arguments in that pattern.
 o toPattern()
Gets the pattern.

Constructors

 o MessageFormat
public MessageFormat(String pattern)
Constructs with the specified pattern.

See Also:
applyPattern

Methods

 o applyPattern
public void applyPattern(String newPattern)
Sets the pattern. See the class description.

 o clone
public java.lang.Object clone()
Overrides Cloneable

Overrides:
clone in class Format
 o equals
public boolean equals(Object obj)
Equality comparision between two message format objects

Overrides:
equals in class Object
 o format
public final java.lang.StringBuffer format(Object[] source,
                                           StringBuffer result,
                                           FieldPosition ignore)
Returns pattern with formatted objects.

Parameters:
source - an array of objects to be formatted & substituted.
result - where text is appended.
ignore - no useful status is returned.
 o format
public static java.lang.String format(String pattern,
                                      Object[] arguments)
Convenience routine. Avoids explicit creation of MessageFormat, but doesn't allow future optimizations.

 o format
public final java.lang.StringBuffer format(Object source,
                                           StringBuffer result,
                                           FieldPosition ignore)
Formats an object to produce a string.

Overrides:
format in class Format
 o getFormats
public java.text.Format[] getFormats()
Gets formats that were set with setFormats. See the class description about format numbering.

 o getLocale
public java.util.Locale getLocale()
Gets the locale. This locale is used for fetching default number or date format information.

 o hashCode
public int hashCode()
Generates a hash code for the message format object.

Overrides:
hashCode in class Object
 o parse
public java.lang.Object[] parse(String source,
                                ParsePosition status)
Parses the string.

Caveats: The parse may fail in a number of circumstances. For example:

 o parse
public java.lang.Object[] parse(String source) throws ParseException
Parses the string. Does not yet handle recursion (where the substituted strings contain {n} references.)

Throws: ParseException
if the string can't be parsed.
 o parseObject
public java.lang.Object parseObject(String text,
                                    ParsePosition status)
Parses the string. Does not yet handle recursion (where the substituted strings contain %n references.)

Overrides:
parseObject in class Format
 o setFormat
public void setFormat(int variable,
                      Format newFormat)
Sets formats individually to use on parameters. See the class description about format numbering.

 o setFormats
public void setFormats(Format[] newFormats)
Sets formats to use on parameters. See the class description about format numbering.

 o setLocale
public void setLocale(Locale theLocale)
Constructs with the specified pattern and formats for the arguments in that pattern.

See Also:
setPattern
 o toPattern
public java.lang.String toPattern()
Gets the pattern. See the class description.


All Packages  Class Hierarchy  This Package  Previous  Next  Index