* {@code MessageFormat} takes a set of objects, formats them, then * inserts the formatted strings into the pattern at the appropriate places. * *
* Note: * {@code MessageFormat} differs from the other {@code Format} * classes in that you create a {@code MessageFormat} object with one * of its constructors (not with a {@code getInstance} style factory * method). The factory methods aren't necessary because {@code MessageFormat} * itself doesn't implement locale specific behavior. Any locale specific * behavior is defined by the pattern that you provide as well as the * subformats used for inserted arguments. * *
* MessageFormatPattern:
* String
* MessageFormatPattern FormatElement String
*
* FormatElement:
* { ArgumentIndex }
* { ArgumentIndex , FormatType }
* { ArgumentIndex , FormatType , FormatStyle }
*
* FormatType:
* number
* dtf_date
* dtf_time
* dtf_datetime
* pre-defined DateTimeFormatter(s)
* date
* time
* choice
* list
*
* FormatStyle:
* short
* medium
* long
* full
* integer
* currency
* percent
* compact_short
* compact_long
* or
* unit
* SubformatPattern
* * The {@code ArgumentIndex} value is a non-negative integer written * using the digits {@code '0'} through {@code '9'}, and represents an index into the * {@code arguments} array passed to the {@code format} methods * or the result array returned by the {@code parse} methods. *
* Any constructor or method that takes a String pattern parameter will throw an {@code IllegalArgumentException} if the * pattern contains an {@code ArgumentIndex} value that is equal to or exceeds an implementation limit. *
* The {@code FormatType} and {@code FormatStyle} values are used to create * a {@code Format} instance for the format element. The following * table shows how the values map to {@code Format} instances. These values * are case-insensitive when passed to {@link #applyPattern(String)}. Combinations * not shown in the table are illegal. A SubformatPattern must * be a valid pattern string for the {@code Format} subclass used. * @implNote In the reference implementation, the limit of {@code ArgumentIndex} is 10,000. * *
| FormatType * | FormatStyle * | Subformat Created * |
|---|---|---|
| (none) * | (none) * | {@code null} * |
| {@code number} * | (none) * | {@link NumberFormat#getInstance(Locale) NumberFormat.getInstance}{@code (getLocale())} * |
| {@code integer} * | {@link NumberFormat#getIntegerInstance(Locale) NumberFormat.getIntegerInstance}{@code (getLocale())} * | |
| {@code currency} * | {@link NumberFormat#getCurrencyInstance(Locale) NumberFormat.getCurrencyInstance}{@code (getLocale())} * | |
| {@code percent} * | {@link NumberFormat#getPercentInstance(Locale) NumberFormat.getPercentInstance}{@code (getLocale())} * | |
| {@code compact_short} * | {@link NumberFormat#getCompactNumberInstance(Locale, NumberFormat.Style) * NumberFormat.getCompactNumberInstance}{@code (getLocale(),} {@link NumberFormat.Style#SHORT}) * | |
| {@code compact_long} * | {@link NumberFormat#getCompactNumberInstance(Locale, NumberFormat.Style) * NumberFormat.getCompactNumberInstance}{@code (getLocale(),} {@link NumberFormat.Style#LONG}) * | |
| SubformatPattern * | {@code new} {@link DecimalFormat#DecimalFormat(String,DecimalFormatSymbols) * DecimalFormat}{@code (subformatPattern,} {@link DecimalFormatSymbols#getInstance(Locale) * DecimalFormatSymbols.getInstance}{@code (getLocale()))} * | |
| {@code dtf_date} * | (none) * | {@link DateTimeFormatter#ofLocalizedDate(java.time.format.FormatStyle) * DateTimeFormatter.ofLocalizedDate(}{@link java.time.format.FormatStyle#MEDIUM}{@code ).withLocale(getLocale())} * |
| {@code short} * | {@link DateTimeFormatter#ofLocalizedDate(java.time.format.FormatStyle) * DateTimeFormatter.ofLocalizedDate(}{@link java.time.format.FormatStyle#SHORT}{@code ).withLocale(getLocale())} * | |
| {@code medium} * | {@link DateTimeFormatter#ofLocalizedDate(java.time.format.FormatStyle) * DateTimeFormatter.ofLocalizedDate(}{@link java.time.format.FormatStyle#MEDIUM}{@code ).withLocale(getLocale())} * | |
| {@code long} * | {@link DateTimeFormatter#ofLocalizedDate(java.time.format.FormatStyle) * DateTimeFormatter.ofLocalizedDate(}{@link java.time.format.FormatStyle#LONG}{@code ).withLocale(getLocale())} * | |
| {@code full} * | {@link DateTimeFormatter#ofLocalizedDate(java.time.format.FormatStyle) * DateTimeFormatter.ofLocalizedDate(}{@link java.time.format.FormatStyle#FULL}{@code ).withLocale(getLocale())} * | |
| SubformatPattern * | {@link DateTimeFormatter#ofPattern(String, Locale) * DateTimeFormatter.ofPattern}{@code (subformatPattern, getLocale())} * | |
| {@code dtf_time} * | (none) * | {@link DateTimeFormatter#ofLocalizedTime(java.time.format.FormatStyle) * DateTimeFormatter.ofLocalizedTime(}{@link java.time.format.FormatStyle#MEDIUM}{@code ).withLocale(getLocale())} * |
| {@code short} * | {@link DateTimeFormatter#ofLocalizedTime(java.time.format.FormatStyle) * DateTimeFormatter.ofLocalizedTime(}{@link java.time.format.FormatStyle#SHORT}{@code ).withLocale(getLocale())} * | |
| {@code medium} * | {@link DateTimeFormatter#ofLocalizedTime(java.time.format.FormatStyle) * DateTimeFormatter.ofLocalizedTime(}{@link java.time.format.FormatStyle#MEDIUM}{@code ).withLocale(getLocale())} * | |
| {@code long} * | {@link DateTimeFormatter#ofLocalizedTime(java.time.format.FormatStyle) * DateTimeFormatter.ofLocalizedTime(}{@link java.time.format.FormatStyle#LONG}{@code ).withLocale(getLocale())} * | |
| {@code full} * | {@link DateTimeFormatter#ofLocalizedTime(java.time.format.FormatStyle) * DateTimeFormatter.ofLocalizedTime(}{@link java.time.format.FormatStyle#FULL}{@code ).withLocale(getLocale())} * | |
| SubformatPattern * | {@link DateTimeFormatter#ofPattern(String, Locale) DateTimeFormatter.ofPattern}{@code (subformatPattern, getLocale())} * | |
| {@code dtf_datetime} * | (none) * | {@link DateTimeFormatter#ofLocalizedDateTime(java.time.format.FormatStyle) * DateTimeFormatter.ofLocalizedDateTime(}{@link java.time.format.FormatStyle#MEDIUM}{@code ).withLocale(getLocale())} * |
| {@code short} * | {@link DateTimeFormatter#ofLocalizedDateTime(java.time.format.FormatStyle) * DateTimeFormatter.ofLocalizedDateTime(}{@link java.time.format.FormatStyle#SHORT}{@code ).withLocale(getLocale())} * | |
| {@code medium} * | {@link DateTimeFormatter#ofLocalizedDateTime(java.time.format.FormatStyle) * DateTimeFormatter.ofLocalizedDateTime(}{@link java.time.format.FormatStyle#MEDIUM}{@code ).withLocale(getLocale())} * | |
| {@code long} * | {@link DateTimeFormatter#ofLocalizedDateTime(java.time.format.FormatStyle) * DateTimeFormatter.ofLocalizedDateTime(}{@link java.time.format.FormatStyle#LONG}{@code ).withLocale(getLocale())} * | |
| {@code full} * | {@link DateTimeFormatter#ofLocalizedDateTime(java.time.format.FormatStyle) * DateTimeFormatter.ofLocalizedDateTime(}{@link java.time.format.FormatStyle#FULL}{@code ).withLocale(getLocale())} * | |
| SubformatPattern * | {@link DateTimeFormatter#ofPattern(String, Locale) * DateTimeFormatter.ofPattern}{@code (subformatPattern, getLocale())} * | |
| {@code pre-defined DateTimeFormatter(s)} * | (none) * | The {@code pre-defined DateTimeFormatter(s)} are used as a {@code FormatType} : * {@link DateTimeFormatter#BASIC_ISO_DATE BASIC_ISO_DATE}, * {@link DateTimeFormatter#ISO_LOCAL_DATE ISO_LOCAL_DATE}, * {@link DateTimeFormatter#ISO_OFFSET_DATE ISO_OFFSET_DATE}, * {@link DateTimeFormatter#ISO_DATE ISO_DATE}, * {@link DateTimeFormatter#ISO_LOCAL_TIME ISO_LOCAL_TIME}, * {@link DateTimeFormatter#ISO_OFFSET_TIME ISO_OFFSET_TIME}, * {@link DateTimeFormatter#ISO_TIME ISO_TIME}, * {@link DateTimeFormatter#ISO_LOCAL_DATE_TIME ISO_LOCAL_DATE_TIME}, * {@link DateTimeFormatter#ISO_OFFSET_DATE_TIME ISO_OFFSET_DATE_TIME}, * {@link DateTimeFormatter#ISO_ZONED_DATE_TIME ISO_ZONED_DATE_TIME}, * {@link DateTimeFormatter#ISO_DATE_TIME ISO_DATE_TIME}, * {@link DateTimeFormatter#ISO_ORDINAL_DATE ISO_ORDINAL_DATE}, * {@link DateTimeFormatter#ISO_WEEK_DATE ISO_WEEK_DATE}, * {@link DateTimeFormatter#ISO_INSTANT ISO_INSTANT}, * {@link DateTimeFormatter#RFC_1123_DATE_TIME RFC_1123_DATE_TIME} * |
| {@code date} * | (none) * | {@link DateFormat#getDateInstance(int,Locale) * DateFormat.getDateInstance}{@code (}{@link DateFormat#DEFAULT}{@code , getLocale())} * |
| {@code short} * | {@link DateFormat#getDateInstance(int,Locale) * DateFormat.getDateInstance}{@code (}{@link DateFormat#SHORT}{@code , getLocale())} * | |
| {@code medium} * | {@link DateFormat#getDateInstance(int,Locale) * DateFormat.getDateInstance}{@code (}{@link DateFormat#MEDIUM}{@code , getLocale())} * | |
| {@code long} * | {@link DateFormat#getDateInstance(int,Locale) * DateFormat.getDateInstance}{@code (}{@link DateFormat#LONG}{@code , getLocale())} * | |
| {@code full} * | {@link DateFormat#getDateInstance(int,Locale) * DateFormat.getDateInstance}{@code (}{@link DateFormat#FULL}{@code , getLocale())} * | |
| SubformatPattern * | {@code new} {@link SimpleDateFormat#SimpleDateFormat(String,Locale) * SimpleDateFormat}{@code (subformatPattern, getLocale())} * | |
| {@code time} * | (none) * | {@link DateFormat#getTimeInstance(int,Locale) * DateFormat.getTimeInstance}{@code (}{@link DateFormat#DEFAULT}{@code , getLocale())} * |
| {@code short} * | {@link DateFormat#getTimeInstance(int,Locale) * DateFormat.getTimeInstance}{@code (}{@link DateFormat#SHORT}{@code , getLocale())} * | |
| {@code medium} * | {@link DateFormat#getTimeInstance(int,Locale) * DateFormat.getTimeInstance}{@code (}{@link DateFormat#MEDIUM}{@code , getLocale())} * | |
| {@code long} * | {@link DateFormat#getTimeInstance(int,Locale) * DateFormat.getTimeInstance}{@code (}{@link DateFormat#LONG}{@code , getLocale())} * | |
| {@code full} * | {@link DateFormat#getTimeInstance(int,Locale) * DateFormat.getTimeInstance}{@code (}{@link DateFormat#FULL}{@code , getLocale())} * | |
| SubformatPattern * | {@code new} {@link SimpleDateFormat#SimpleDateFormat(String,Locale) * SimpleDateFormat}{@code (subformatPattern, getLocale())} * | |
| {@code choice} * | SubformatPattern * | {@code new} {@link ChoiceFormat#ChoiceFormat(String) ChoiceFormat}{@code (subformatPattern)} * |
| {@code list} * | (none) * | {@link ListFormat#getInstance(Locale, ListFormat.Type, ListFormat.Style) * ListFormat.getInstance}{@code (getLocale()}, {@link ListFormat.Type#STANDARD}, {@link ListFormat.Style#FULL}{@code )} * |
| {@code or} * | {@link ListFormat#getInstance(Locale, ListFormat.Type, ListFormat.Style) * ListFormat.getInstance}{@code (getLocale()}, {@link ListFormat.Type#OR}, {@link ListFormat.Style#FULL}{@code )} * | |
| {@code unit} * | {@link ListFormat#getInstance(Locale, ListFormat.Type, ListFormat.Style) * ListFormat.getInstance}{@code (getLocale()}, {@link ListFormat.Type#UNIT}, {@link ListFormat.Style#FULL}{@code )} * |
Within a String, a pair of single quotes can be used to
* quote any arbitrary characters except single quotes. For example,
* pattern string "'{0}'" represents string
* "{0}", not a FormatElement. A single quote itself
* must be represented by doubled single quotes {@code ''} throughout a
* String. For example, pattern string "'{''}'" is
* interpreted as a sequence of '{ (start of quoting and a
* left curly brace), {@code ''} (a single quote), and
* }' (a right curly brace and end of quoting),
* not '{' and '}' (quoted left and
* right curly braces): representing string "{'}",
* not "{}".
*
*
A SubformatPattern is interpreted by its corresponding
* subformat, and subformat-dependent pattern rules apply. For example,
* pattern string "{1,number,$'#',##}"
* (SubformatPattern with underline) will produce a number format
* with the pound-sign quoted, with a result such as: {@code
* "$#31,45"}. Refer to each {@code Format} subclass documentation for
* details.
*
*
Any unmatched quote is treated as closed at the end of the given * pattern. For example, pattern string {@code "'{0}"} is treated as * pattern {@code "'{0}'"}. * *
Any curly braces within an unquoted pattern must be balanced. For
* example, "ab {0} de" and "ab '}' de" are
* valid patterns, but "ab {0'}' de", "ab } de"
* and "''{''" are not.
*
*
* ** At 12:30:00 PM on Jul 3, 2053, there was a disturbance in the Force on planet 7. *
* For more sophisticated patterns, {@link ChoiceFormat} can be used with * {@code MessageFormat} to produce accurate forms for singular and plural: * {@snippet lang=java : * MessageFormat msgFmt = new MessageFormat("The disk \"{0}\" contains {1,choice,0#no files|1#one file|1< {1,number,integer} files}."); * Object[] args = {"MyDisk", fileCount}; * String result = msgFmt.format(args); * } * * {@code result} with different values for {@code fileCount}, returns the following: *
* ** The disk "MyDisk" contains no files. * The disk "MyDisk" contains one file. * The disk "MyDisk" contains 1,273 files. *
* Notes: As seen in the previous snippet, * the string produced by a {@code ChoiceFormat} in {@code MessageFormat} is * treated as special; occurrences of '{' are used to indicate subformats, and * cause recursion. If a {@code FormatElement} is defined in the {@code ChoiceFormat} * pattern, it will only be formatted according to the {@code FormatType} and * {@code FormatStyle} pattern provided. The associated subformats of the * top level {@code MessageFormat} will not be applied to the {@code FormatElement} * defined in the {@code ChoiceFormat} pattern. * If you create both a {@code MessageFormat} and {@code 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. * *
1) a date {@code FormatType} with a full {@code FormatStyle}, * {@snippet lang=java : * Object[] arg = {new GregorianCalendar(2023, Calendar.NOVEMBER, 16).getTime()}; * var fmt = new MessageFormat("The date was {0,date,full}"); * fmt.format(arg); // returns "The date was Thursday, November 16, 2023" * } * *
2) a dtf_date {@code FormatType} with a full {@code FormatStyle}, * {@snippet lang=java : * Object[] arg = {LocalDate.of(2023, 11, 16)}; * var fmt = new MessageFormat("The date was {0,dtf_date,full}"); * fmt.format(arg); // returns "The date was Thursday, November 16, 2023" * } * *
3) an ISO_LOCAL_DATE {@code FormatType}, * {@snippet lang=java : * Object[] arg = {LocalDate.of(2023, 11, 16)}; * var fmt = new MessageFormat("The date was {0,ISO_LOCAL_DATE}"); * fmt.format(arg); // returns "The date was 2023-11-16" * } * *
* When a single argument is parsed more than once in the string, the last match * will be the final result of the parsing. For example, * {@snippet lang=java : * MessageFormat mf = new MessageFormat("{0,number,#.##}, {0,number,#.#}"); * Object[] objs = {Double.valueOf(3.1415)}; * String result = mf.format( objs ); * // result now equals "3.14, 3.1" * objs = mf.parse(result, new ParsePosition(0)); * // objs now equals {Double.valueOf(3.1)} * } * *
* Likewise, parsing with a {@code MessageFormat} object using patterns containing * multiple occurrences of the same argument would return the last match. For * example, * {@snippet lang=java : * MessageFormat mf = new MessageFormat("{0}, {0}, {0}"); * String forParsing = "x, y, z"; * Object[] objs = mf.parse(forParsing, new ParsePosition(0)); * // objs now equals {new String("z")} * } * *
* Message formats are not synchronized. * It is recommended to create separate format instances for each thread. * If multiple threads access a format concurrently, it must be synchronized * externally. * * @see java.util.Locale * @see Format * @see NumberFormat * @see DecimalFormat * @see DecimalFormatSymbols * @see ChoiceFormat * @see DateFormat * @see SimpleDateFormat * @see DateTimeFormatter * * @author Mark Davis * @since 1.1 */ public class MessageFormat extends Format { @java.io.Serial private static final long serialVersionUID = 6479157306784022952L; /** * Constructs a MessageFormat for the default * {@link java.util.Locale.Category#FORMAT FORMAT} locale and the * specified pattern. * The constructor first sets the locale, then parses the pattern and * creates a list of subformats for the format elements contained in it. * Patterns and their interpretation are specified in the * {@linkplain ##patterns class description}. * * @param pattern the pattern for this message format * @throws IllegalArgumentException if the pattern is invalid * @throws NullPointerException if {@code pattern} is * {@code null} */ public MessageFormat(String pattern) { this.locale = Locale.getDefault(Locale.Category.FORMAT); applyPatternImpl(pattern); } /** * Constructs a MessageFormat for the specified locale and * pattern. * The constructor first sets the locale, then parses the pattern and * creates a list of subformats for the format elements contained in it. * Patterns and their interpretation are specified in the * {@linkplain ##patterns class description}. * * @implSpec The default implementation throws a * {@code NullPointerException} if {@code locale} is {@code null} * either during the creation of the {@code MessageFormat} object or later * when {@code format()} is called by a {@code MessageFormat} * instance with a null locale and the implementation utilizes a * locale-dependent subformat. * * @param pattern the pattern for this message format * @param locale the locale for this message format * @throws IllegalArgumentException if the pattern is invalid * @throws NullPointerException if {@code pattern} is * {@code null} or {@code locale} is {@code null} and the * implementation uses a locale-dependent subformat. * @since 1.4 */ public MessageFormat(String pattern, Locale locale) { this.locale = locale; applyPatternImpl(pattern); } /** * Sets the locale to be used when creating or comparing subformats. * This affects subsequent calls *
In addition, since DateTimeFormatter and ClassicFormat do not implement {@code equals()}, * there is not a means to compare {@code fmt} to a ClassicFormat for equality, * and thus we don't have enough info to represent it as a pattern since there is no way to check * if {@code fmt} is equal to some, (for example, "long" style) pre-defined ClassicFormat. * Even if ClassicFormat implemented equals(), it is a wrapper class for * DateTimeFormatter, which would require DTF to implement equals() as well to effectively * compare the two ClassicFormats. */ private String patternFromFormat(Format fmt) { if (fmt instanceof NumberFormat nFmt) { // Check nFmt factory instances String nStyle = NumberFormat.matchToStyle(nFmt, locale); if (nStyle != null) { return ",number" + (nStyle.isEmpty() ? nStyle : "," + nStyle); } // Check SubformatPattern if (fmt instanceof DecimalFormat dFmt) { // Quote eligible mFmt pattern characters: '{' and '}' // Here, and in other subformatPattern instances return ",number," + copyAndQuoteBraces(dFmt.toPattern()); } else if (fmt instanceof ChoiceFormat cFmt) { return ",choice," + copyAndQuoteBraces(cFmt.toPattern()); } } else if (fmt instanceof DateFormat) { // Check dFmt factory instances for (DateFormat.Style style : DateFormat.Style.values()) { if (fmt.equals(DateFormat.getDateInstance(style.getValue(), locale))) { return ",date" + ((style.getValue() != DateFormat.DEFAULT) ? "," + style.name().toLowerCase(Locale.ROOT) : ""); } if (fmt.equals(DateFormat.getTimeInstance(style.getValue(), locale))) { return ",time" + ((style.getValue() != DateFormat.DEFAULT) ? "," + style.name().toLowerCase(Locale.ROOT) : ""); } } // Check SubformatPattern if (fmt instanceof SimpleDateFormat sdFmt) { return ",date," + copyAndQuoteBraces(sdFmt.toPattern()); } } else if (fmt instanceof ListFormat) { // Check lFmt factory instances for (ListFormat.Type type : ListFormat.Type.values()) { if (fmt.equals(ListFormat.getInstance(locale, type, ListFormat.Style.FULL))) { return ",list" + ((type != ListFormat.Type.STANDARD) ? "," + type.name().toLowerCase(Locale.ROOT) : ""); } } } // By here, this is an instanceof Format that is unknown to MessageFormat. // Since it is unknown, nothing can be done. return ""; } /** * Sets the formats to use for the values passed into * {@code format} methods or returned from {@code parse} * methods. The indices of elements in {@code newFormats} * correspond to the argument indices used in the previously set * pattern string. * The order of formats in {@code newFormats} thus corresponds to * the order of elements in the {@code arguments} array passed * to the {@code format} methods or the result array returned * by the {@code parse} methods. *
* If an argument index is used for more than one format element * in the pattern string, then the corresponding new format is used * for all such format elements. If an argument index is not used * for any format element in the pattern string, then the * corresponding new format is ignored. If fewer formats are provided * than needed, then only the formats for argument indices less * than {@code newFormats.length} are replaced. * * @param newFormats the new formats to use * @throws NullPointerException if {@code newFormats} is null * @since 1.4 */ public void setFormatsByArgumentIndex(Format[] newFormats) { for (int i = 0; i <= maxOffset; i++) { int j = argumentNumbers[i]; if (j < newFormats.length) { formats[i] = newFormats[j]; } } } /** * Sets the formats to use for the format elements in the * previously set pattern string. * The order of formats in {@code newFormats} corresponds to * the order of format elements in the pattern string. *
* If more formats are provided than needed by the pattern string, * the remaining ones are ignored. If fewer formats are provided * than needed, then only the first {@code newFormats.length} * formats are replaced. *
* Since the order of format elements in a pattern string often * changes during localization, it is generally better to use the * {@link #setFormatsByArgumentIndex setFormatsByArgumentIndex} * method, which assumes an order of formats corresponding to the * order of elements in the {@code arguments} array passed to * the {@code format} methods or the result array returned by * the {@code parse} methods. * * @param newFormats the new formats to use * @throws NullPointerException if {@code newFormats} is null */ public void setFormats(Format[] newFormats) { int runsToCopy = newFormats.length; if (runsToCopy > maxOffset + 1) { runsToCopy = maxOffset + 1; } if (runsToCopy >= 0) System.arraycopy(newFormats, 0, formats, 0, runsToCopy); } /** * Sets the format to use for the format elements within the * previously set pattern string that use the given argument * index. * The argument index is part of the format element definition and * represents an index into the {@code arguments} array passed * to the {@code format} methods or the result array returned * by the {@code parse} methods. *
* If the argument index is used for more than one format element * in the pattern string, then the new format is used for all such * format elements. If the argument index is not used for any format * element in the pattern string, then the new format is ignored. * * @param argumentIndex the argument index for which to use the new format * @param newFormat the new format to use * @since 1.4 */ public void setFormatByArgumentIndex(int argumentIndex, Format newFormat) { for (int j = 0; j <= maxOffset; j++) { if (argumentNumbers[j] == argumentIndex) { formats[j] = newFormat; } } } /** * Sets the format to use for the format element with the given * format element index within the previously set pattern string. * The format element index is the zero-based number of the format * element counting from the start of the pattern string. *
* Since the order of format elements in a pattern string often * changes during localization, it is generally better to use the * {@link #setFormatByArgumentIndex setFormatByArgumentIndex} * method, which accesses format elements based on the argument * index they specify. * * @param formatElementIndex the index of a format element within the pattern * @param newFormat the format to use for the specified format element * @throws ArrayIndexOutOfBoundsException if {@code formatElementIndex} is equal to or * larger than the number of format elements in the pattern string */ public void setFormat(int formatElementIndex, Format newFormat) { if (formatElementIndex > maxOffset) { throw new ArrayIndexOutOfBoundsException(formatElementIndex); } formats[formatElementIndex] = newFormat; } /** * Gets the formats used for the values passed into * {@code format} methods or returned from {@code parse} * methods. The indices of elements in the returned array * correspond to the argument indices used in the previously set * pattern string. * The order of formats in the returned array thus corresponds to * the order of elements in the {@code arguments} array passed * to the {@code format} methods or the result array returned * by the {@code parse} methods. *
* If an argument index is used for more than one format element * in the pattern string, then the format used for the last such * format element is returned in the array. If an argument index * is not used for any format element in the pattern string, then * null is returned in the array. * * @return the formats used for the arguments within the pattern * @since 1.4 */ public Format[] getFormatsByArgumentIndex() { int maximumArgumentNumber = -1; for (int i = 0; i <= maxOffset; i++) { if (argumentNumbers[i] > maximumArgumentNumber) { maximumArgumentNumber = argumentNumbers[i]; } } Format[] resultArray = new Format[maximumArgumentNumber + 1]; for (int i = 0; i <= maxOffset; i++) { resultArray[argumentNumbers[i]] = formats[i]; } return resultArray; } /** * Gets the formats used for the format elements in the * previously set pattern string. * The order of formats in the returned array corresponds to * the order of format elements in the pattern string. *
* Since the order of format elements in a pattern string often * changes during localization, it's generally better to use the * {@link #getFormatsByArgumentIndex getFormatsByArgumentIndex} * method, which assumes an order of formats corresponding to the * order of elements in the {@code arguments} array passed to * the {@code format} methods or the result array returned by * the {@code parse} methods. * * @return the formats used for the format elements in the pattern */ public Format[] getFormats() { Format[] resultArray = new Format[maxOffset + 1]; System.arraycopy(formats, 0, resultArray, 0, maxOffset + 1); return resultArray; } /** * Formats an array of objects and appends the {@code MessageFormat}'s * pattern, with format elements replaced by the formatted objects, to the * provided {@code StringBuffer}. *
* The text substituted for the individual format elements is derived from * the current subformat of the format element and the * {@code arguments} element at the format element's argument index * as indicated by the first matching line of the following table. An * argument is unavailable if {@code arguments} is * {@code null} or has fewer than argumentIndex+1 elements. * *
| Subformat * | Argument * | Formatted Text * |
|---|---|---|
| any * | unavailable * | "{" + argumentIndex + "}"
* |
| {@code null} * | {@code "null"} * | |
| {@code instanceof ChoiceFormat} * | any * | subformat.format(argument).indexOf('{') >= 0 ?
* |
| {@code != null} * | any * | {@code subformat.format(argument)} * |
| {@code null} * | {@code instanceof Number} * | {@code NumberFormat.getInstance(getLocale()).format(argument)} * |
| {@code instanceof Date} * | {@code DateFormat.getDateTimeInstance(DateFormat.SHORT, DateFormat.SHORT, getLocale()).format(argument)} * | |
| {@code instanceof String} * | {@code argument} * | |
| any * | {@code argument.toString()} * |
* If {@code pos} is non-null, and refers to * {@code Field.ARGUMENT}, the location of the first formatted * string will be returned. * * @param arguments an array of objects to be formatted and substituted. * @param result where text is appended. * @param pos keeps track on the position of the first replaced argument * in the output string. * @return the string buffer passed in as {@code result}, with formatted * text appended * @throws IllegalArgumentException if an argument in the * {@code arguments} array is not of the type * expected by the format element(s) that use it. * @throws NullPointerException if {@code result} is {@code null} or * if the {@code MessageFormat} instance that calls this method * has locale set to null, and the implementation * uses a locale-dependent subformat. */ public final StringBuffer format(Object[] arguments, StringBuffer result, FieldPosition pos) { return subformat(arguments, StringBufFactory.of(result), pos, null).asStringBuffer(); } /** * Creates a MessageFormat with the given pattern and uses it * to format the given arguments. * This method returns a string that would be equal to the string returned by *
* (new {@link #MessageFormat(String) MessageFormat}(pattern)).{@link #format(java.lang.Object[], java.lang.StringBuffer, java.text.FieldPosition) format}(arguments, new StringBuffer(), null).toString()
*
*
* @param pattern the pattern string
* @param arguments object(s) to format
* @return the formatted string
* @throws IllegalArgumentException if the pattern is invalid,
* or if an argument in the {@code arguments} array
* is not of the type expected by the format element(s)
* that use it.
* @throws NullPointerException if {@code pattern} is {@code null}
*/
public static String format(String pattern, Object ... arguments) {
MessageFormat temp = new MessageFormat(pattern);
return temp.format(arguments);
}
// Overrides
/**
* Formats an array of objects and appends the {@code MessageFormat}'s
* pattern, with format elements replaced by the formatted objects, to the
* provided {@code StringBuffer}.
* This is equivalent to
*
* {@link #format(java.lang.Object[], java.lang.StringBuffer, java.text.FieldPosition) format}((Object[]) arguments, result, pos)
*
*
* @param arguments an array of objects to be formatted and substituted.
* @param result where text is appended.
* @param pos keeps track on the position of the first replaced argument
* in the output string.
* @throws IllegalArgumentException if an argument in the
* {@code arguments} array is not of the type
* expected by the format element(s) that use it.
* @throws NullPointerException if {@code result} is {@code null} or
* if the {@code MessageFormat} instance that calls this method
* has locale set to null, and the implementation
* uses a locale-dependent subformat.
*/
public final StringBuffer format(Object arguments, StringBuffer result,
FieldPosition pos)
{
return subformat((Object[]) arguments, StringBufFactory.of(result), pos, null).asStringBuffer();
}
@Override
final StringBuf format(Object arguments, StringBuf result,
FieldPosition pos) {
return subformat((Object[]) arguments, result, pos, null);
}
/**
* Formats an array of objects and inserts them into the
* {@code MessageFormat}'s pattern, producing an
* {@code AttributedCharacterIterator}.
* You can use the returned {@code AttributedCharacterIterator}
* to build the resulting String, as well as to determine information
* about the resulting String.
* * The text of the returned {@code AttributedCharacterIterator} is * the same that would be returned by *
* {@link #format(java.lang.Object[], java.lang.StringBuffer, java.text.FieldPosition) format}(arguments, new StringBuffer(), null).toString()
*
* * In addition, the {@code AttributedCharacterIterator} contains at * least attributes indicating where text was generated from an * argument in the {@code arguments} array. The keys of these attributes are of * type {@code MessageFormat.Field}, their values are * {@code Integer} objects indicating the index in the {@code arguments} * array of the argument from which the text was generated. *
* The attributes/value from the underlying {@code Format}
* instances that {@code MessageFormat} uses will also be
* placed in the resulting {@code AttributedCharacterIterator}.
* This allows you to not only find where an argument is placed in the
* resulting String, but also which fields it contains in turn.
*
* @param arguments an array of objects to be formatted and substituted.
* @return AttributedCharacterIterator describing the formatted value.
* @throws NullPointerException if {@code arguments} is null.
* @throws IllegalArgumentException if an argument in the
* {@code arguments} array is not of the type
* expected by the format element(s) that use it.
* @since 1.4
*/
public AttributedCharacterIterator formatToCharacterIterator(Object arguments) {
Objects.requireNonNull(arguments, "arguments must not be null");
StringBuf result = StringBufFactory.of();
ArrayList Caveats: The parse may fail in a number of circumstances.
* For example:
*
* See the {@link #parse(String, ParsePosition)} method for more information
* on message parsing.
*
* @param source A {@code String} whose beginning should be parsed.
* @return An {@code Object} array parsed from the string.
* @throws ParseException if the beginning of the specified string
* cannot be parsed.
*/
public Object[] parse(String source) throws ParseException {
ParsePosition pos = new ParsePosition(0);
Object[] result = parse(source, pos);
if (pos.index == 0) // unchanged, returned object is null
throw new ParseException("MessageFormat parse error!", pos.errorIndex);
return result;
}
/**
* Parses text from a string to produce an object array.
*
* The method attempts to parse text starting at the index given by
* {@code pos}.
* If parsing succeeds, then the index of {@code pos} 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 array is returned. The updated {@code pos} can be used to
* indicate the starting point for the next call to this method.
* If an error occurs, then the index of {@code pos} is not
* changed, the error index of {@code pos} is set to the index of
* the character where the error occurred, and null is returned.
*
* See the {@link #parse(String, ParsePosition)} method for more information
* on message parsing.
*
* @param source A {@code String}, part of which should be parsed.
* @param pos A {@code ParsePosition} object with index and error
* index information as described above.
* @return An {@code Object} array parsed from the string. In case of
* error, returns null.
* @throws NullPointerException if {@code pos} is null.
*/
public Object parseObject(String source, ParsePosition pos) {
return parse(source, pos);
}
/**
* Creates and returns a copy of this object.
*
* @return a clone of this instance.
*/
public Object clone() {
MessageFormat other = (MessageFormat) super.clone();
// clone arrays. Can't do with utility because of bug in Cloneable
other.formats = formats.clone(); // shallow clone
for (int i = 0; i < formats.length; ++i) {
if (formats[i] != null)
other.formats[i] = (Format)formats[i].clone();
}
// for primitives or immutables, shallow clone is enough
other.offsets = offsets.clone();
other.argumentNumbers = argumentNumbers.clone();
return other;
}
/**
* Compares the specified object with this {@code MessageFormat} for equality.
* Returns true if the object is also a {@code MessageFormat} and the
* two formats would format any value the same.
*
* @implSpec This method performs an equality check with a notion of class
* identity based on {@code getClass()}, rather than {@code instanceof}.
* Therefore, in the equals methods in subclasses, no instance of this class
* should compare as equal to an instance of a subclass.
* @param obj object to be compared for equality
* @return {@code true} if the specified object is equal to this {@code MessageFormat}
* @see Object#equals(Object)
*/
@Override
public boolean equals(Object obj) {
if (this == obj) // quick check
return true;
if (obj == null || getClass() != obj.getClass())
return false;
MessageFormat other = (MessageFormat) obj;
return (maxOffset == other.maxOffset
&& pattern.equals(other.pattern)
&& Objects.equals(locale,other.locale)
&& Arrays.equals(offsets,other.offsets)
&& Arrays.equals(argumentNumbers,other.argumentNumbers)
&& Arrays.equals(formats,other.formats));
}
/**
* {@return the hash code value for this {@code MessageFormat}}
*
* @implSpec This method calculates the hash code value using the value returned by
* {@link #toPattern()}.
* @see Object#hashCode()
*/
@Override
public int hashCode() {
return pattern.hashCode(); // enough for reasonable distribution
}
/**
* {@return a string identifying this {@code MessageFormat}, for debugging}
*/
@Override
public String toString() {
return
"""
MessageFormat [locale: %s, pattern: "%s"]
""".formatted(locale == null ? null : '"' + locale.getDisplayName() + '"', toPattern());
}
/**
* Defines constants that are used as attribute keys in the
* {@code AttributedCharacterIterator} returned
* from {@code MessageFormat.formatToCharacterIterator}.
*
* @since 1.4
*/
public static class Field extends Format.Field {
// Proclaim serial compatibility with 1.4 FCS
@java.io.Serial
private static final long serialVersionUID = 7899943957617360810L;
/**
* Creates a Field with the specified name.
*
* @param name Name of the attribute
*/
protected Field(String name) {
super(name);
}
/**
* Resolves instances being deserialized to the predefined constants.
*
* @throws InvalidObjectException if the constant could not be
* resolved.
* @return resolved MessageFormat.Field constant
*/
@java.io.Serial
protected Object readResolve() throws InvalidObjectException {
if (this.getClass() != MessageFormat.Field.class) {
throw new InvalidObjectException("subclass didn't correctly implement readResolve");
}
return ARGUMENT;
}
//
// The constants
//
/**
* Constant identifying a portion of a message that was generated
* from an argument passed into {@code formatToCharacterIterator}.
* The value associated with the key will be an {@code Integer}
* indicating the index in the {@code arguments} array of the
* argument from which the text was generated.
*/
public static final Field ARGUMENT =
new Field("message argument field");
}
// ===========================privates============================
/**
* The locale to use for formatting numbers and dates.
* @serial
*/
private Locale locale;
/**
* The string that the formatted values are to be plugged into. In other words, this
* is the pattern supplied on construction with all of the {} expressions taken out.
* @serial
*/
private String pattern = "";
/** The initially expected number of subformats in the format */
private static final int INITIAL_FORMATS = 10;
/**
* An array of formatters, which are used to format the arguments.
* @serial
*/
private Format[] formats = new Format[INITIAL_FORMATS];
/**
* The positions where the results of formatting each argument are to be inserted
* into the pattern.
* @serial
*/
private int[] offsets = new int[INITIAL_FORMATS];
/**
* The argument numbers corresponding to each formatter. (The formatters are stored
* in the order they occur in the pattern, not in the order in which the arguments
* are specified.)
* @serial
*/
private int[] argumentNumbers = new int[INITIAL_FORMATS];
// Implementation limit for ArgumentIndex pattern element. Valid indices must
// be less than this value
private static final int MAX_ARGUMENT_INDEX = 10000;
/**
* One less than the number of entries in {@code offsets}. Can also be thought of
* as the index of the highest-numbered element in {@code offsets} that is being used.
* All of these arrays should have the same number of elements being used as {@code offsets}
* does, and so this variable suffices to tell us how many entries are in all of them.
* @serial
*/
private int maxOffset = -1;
/**
* Internal routine used by format. If {@code characterIterators} is
* {@code non-null}, AttributedCharacterIterator will be created from the
* subformats as necessary. If {@code characterIterators} is {@code null}
* and {@code fp} is {@code non-null} and identifies
* {@code Field.ARGUMENT} as the field attribute, the location of
* the first replaced argument will be set in it.
*
* @throws IllegalArgumentException if an argument in the
* {@code arguments} array is not of the type
* expected by the format element(s) that use it.
*/
private StringBuf subformat(Object[] arguments, StringBuf result,
FieldPosition fp, List
*
* When the parse fails, use ParsePosition.getErrorIndex() to find out
* where in the string the parsing failed. The returned error
* index is the starting offset of the sub-patterns that the string
* is comparing with. For example, if the parsing string "AAA {0} BBB"
* is comparing against the pattern "AAD {0} BBB", the error index is
* 0. When an error occurs, the call to this method will return null.
* If the source is null, return an empty array.
*
* @param source the string to parse
* @param pos the parse position
* @return an array of parsed objects
* @throws NullPointerException if {@code pos} is {@code null}
* for a non-null {@code source} string.
*/
public Object[] parse(String source, ParsePosition pos) {
if (source == null) {
Object[] empty = {};
return empty;
}
int maximumArgumentNumber = -1;
for (int i = 0; i <= maxOffset; i++) {
if (argumentNumbers[i] > maximumArgumentNumber) {
maximumArgumentNumber = argumentNumbers[i];
}
}
// Constructors/applyPattern ensure that resultArray.length < MAX_ARGUMENT_INDEX
Object[] resultArray = new Object[maximumArgumentNumber + 1];
int patternOffset = 0;
int sourceOffset = pos.index;
ParsePosition tempStatus = new ParsePosition(0);
for (int i = 0; i <= maxOffset; ++i) {
// match up to format
int len = offsets[i] - patternOffset;
if (len == 0 || pattern.regionMatches(patternOffset,
source, sourceOffset, len)) {
sourceOffset += len;
patternOffset += len;
} else {
pos.errorIndex = sourceOffset;
return null; // leave index as is to signal error
}
// now use format
if (formats[i] == null) { // string format
// if at end, use longest possible match
// otherwise uses first match to intervening string
// does NOT recursively try all possibilities
int tempLength = (i != maxOffset) ? offsets[i+1] : pattern.length();
int next;
if (patternOffset >= tempLength) {
next = source.length();
}else{
next = source.indexOf(pattern.substring(patternOffset, tempLength),
sourceOffset);
}
if (next < 0) {
pos.errorIndex = sourceOffset;
return null; // leave index as is to signal error
} else {
String strValue= source.substring(sourceOffset,next);
if (!strValue.equals("{" + argumentNumbers[i] + "}"))
resultArray[argumentNumbers[i]]
= source.substring(sourceOffset,next);
sourceOffset = next;
}
} else {
tempStatus.index = sourceOffset;
resultArray[argumentNumbers[i]]
= formats[i].parseObject(source,tempStatus);
if (tempStatus.index == sourceOffset) {
pos.errorIndex = sourceOffset;
return null; // leave index as is to signal error
}
sourceOffset = tempStatus.index; // update
}
}
int len = pattern.length() - patternOffset;
if (len == 0 || pattern.regionMatches(patternOffset,
source, sourceOffset, len)) {
pos.index = sourceOffset + len;
} else {
pos.errorIndex = sourceOffset;
return null; // leave index as is to signal error
}
return resultArray;
}
/**
* Parses text from the beginning of the given string to produce an object
* array.
* The method may not use the entire text of the given string.
*