    All Packages  Class Hierarchy  This Package  Previous  Next  Index

# Class java.text.MessageFormat

    java.lang.Object
       |
       +----java.text.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}...",

- format0 affects the first variable {2}
- format1 affects the second variable {3}
- format2 affects the second variable {0}
- and so on.

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

See Also:
  Locale, Format, NumberFormat, DecimalFormat, ChoiceFormat

##

MessageFormat(String)
  Constructs with the specified pattern.

##

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

##

MessageFormat

     public MessageFormat(String pattern)

  Constructs with the specified pattern.

  See Also:
    applyPattern

##

setLocale

     public void setLocale(Locale theLocale)

  Constructs with the specified pattern and formats for the arguments in that pattern.

  See Also:
    setPattern

getLocale

     public Locale getLocale()

  Gets the locale. This locale is used for fetching default number or date format information.

applyPattern

     public void applyPattern(String newPattern)

  Sets the pattern. See the class description.

toPattern

     public String toPattern()

  Gets the pattern. See the class description.

setFormats

     public void setFormats(Format newFormats[])

  Sets formats to use on parameters. See the class description about format numbering.

setFormat

     public void setFormat(int variable,
                           Format newFormat)

  Sets formats individually to use on parameters. See the class description about format numbering.

getFormats

     public Format[] getFormats()

  Gets formats that were set with setFormats. See the class description about format numbering.

format

     public final 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.

format

     public static String format(String pattern,
                                 Object arguments[])

  Convenience routine. Avoids explicit creation of MessageFormat, but doesn't allow future optimizations.

format

     public final StringBuffer format(Object source,
                                      StringBuffer result,
                                      FieldPosition ignore)

  Formats an object to produce a string.

  Overrides:
    format in class Format

parse

     public Object[] parse(String source,
                           ParsePosition status)

  Parses the string.

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

  - If one of the arguments does not occur in the pattern.
  - If the format of an argument is loses information, such as with a choice format where a large number formats to "many".
  - Does not yet handle recursion (where the substituted strings contain {n} references.)
  - Will not always find a match (or the correct match) if some part of the parse is ambiguous. For example, if the pattern "{1},{2}" is used with the string arguments {"a,b", "c"}, it will format as "a,b,c". When the result is parsed, it will return {"a", "b,c"}.
  - If a single argument is formatted twice in the string, then the later parse wins.

parse

     public 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.

parseObject

     public 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

clone

     public Object clone()

  Overrides Cloneable

  Overrides:
    clone in class Format

equals

     public boolean equals(Object obj)

  Equality comparision between two message format objects

  Overrides:
    equals in class Object

hashCode

     public int hashCode()

  Generates a hash code for the message format object.

  Overrides:
    hashCode in class Object

    All Packages  Class Hierarchy  This Package  Previous  Next  Index

Submit a bug or feature - Version 1.1.8 of Java Platform API Specification
Java is a trademark or registered trademark of Sun Microsystems, Inc. in the US and other countries.
Copyright 1995-1999 Sun Microsystems, Inc. 901 San Antonio Road,
Palo Alto, California, 94303, U.S.A. All Rights Reserved.