* Typically you shouldn't use {@code DateFormatSymbols} directly. * Rather, you are encouraged to create a date-time formatter with the * {@code DateFormat} class's factory methods: {@code getTimeInstance}, * {@code getDateInstance}, or {@code getDateTimeInstance}. * These methods automatically create a {@code DateFormatSymbols} for * the formatter so that you don't have to. After the * formatter is created, you may modify its format pattern using the * {@code setPattern} method. For more information about * creating formatters using {@code DateFormat}'s factory methods, * see {@link DateFormat}. * *
* If you decide to create a date-time formatter with a specific * format pattern for a specific locale, you can do so with: *
** ** new SimpleDateFormat(aPattern, DateFormatSymbols.getInstance(aLocale)). **
* {@code DateFormatSymbols} objects are cloneable. When you obtain * a {@code DateFormatSymbols} object, feel free to modify the * date-time formatting data. For instance, you can replace the localized * date-time format pattern characters with the ones that you feel easy * to remember. Or you can change the representative cities * to your favorite ones. * *
* New {@code DateFormatSymbols} subclasses may be added to support * {@code SimpleDateFormat} for date-time formatting for additional locales. * * @see DateFormat * @see SimpleDateFormat * @see java.util.SimpleTimeZone * @author Chen-Lieh Huang * @since 1.1 */ public class DateFormatSymbols implements Serializable, Cloneable { // Android-changed: Removed reference to DateFormatSymbolsProvider but suggested getInstance(). // be used instead in case Android supports it in future. /** * Construct a DateFormatSymbols object by loading format data from * resources for the default {@link java.util.Locale.Category#FORMAT FORMAT} * locale. It is recommended that the {@link #getInstance(Locale) getInstance} method is used * instead. *
This is equivalent to calling * {@link #DateFormatSymbols(Locale) * DateFormatSymbols(Locale.getDefault(Locale.Category.FORMAT))}. * @see #getInstance() * @see java.util.Locale#getDefault(java.util.Locale.Category) * @see java.util.Locale.Category#FORMAT * @throws java.util.MissingResourceException * if the resources for the default locale cannot be * found or cannot be loaded. */ public DateFormatSymbols() { initializeData(Locale.getDefault(Locale.Category.FORMAT)); } // Android-changed: Removed reference to DateFormatSymbolsProvider but suggested getInstance(). // be used instead in case Android supports it in future. /** * Construct a DateFormatSymbols object by loading format data from * resources for the given locale. It is recommended that the * {@link #getInstance(Locale) getInstance} method is used instead. * * @param locale the desired locale * @see #getInstance(Locale) * @throws java.util.MissingResourceException * if the resources for the specified locale cannot be * found or cannot be loaded. */ public DateFormatSymbols(Locale locale) { initializeData(locale); } // Android-removed: unused private DateFormatSymbols(boolean) constructor. /** * Era strings. For example: "AD" and "BC". An array of 2 strings, * indexed by {@code Calendar.BC} and {@code Calendar.AD}. * @serial */ String eras[] = null; /** * Month strings. For example: "January", "February", etc. An array * of 13 strings (some calendars have 13 months), indexed by * {@code Calendar.JANUARY}, {@code Calendar.FEBRUARY}, etc. * @serial */ String months[] = null; /** * Short month strings. For example: "Jan", "Feb", etc. An array of * 13 strings (some calendars have 13 months), indexed by * {@code Calendar.JANUARY}, {@code Calendar.FEBRUARY}, etc. * @serial */ String shortMonths[] = null; /** * Weekday strings. For example: "Sunday", "Monday", etc. An array * of 8 strings, indexed by {@code Calendar.SUNDAY}, * {@code Calendar.MONDAY}, etc. * The element {@code weekdays[0]} is ignored. * @serial */ String weekdays[] = null; /** * Short weekday strings. For example: "Sun", "Mon", etc. An array * of 8 strings, indexed by {@code Calendar.SUNDAY}, * {@code Calendar.MONDAY}, etc. * The element {@code shortWeekdays[0]} is ignored. * @serial */ String shortWeekdays[] = null; /** * AM and PM strings. For example: "AM" and "PM". An array of * 2 strings, indexed by {@code Calendar.AM} and * {@code Calendar.PM}. * @serial */ String ampms[] = null; /** * Localized names of time zones in this locale. This is a * two-dimensional array of strings of size n by m, * where m is at least 5. Each of the n rows is an * entry containing the localized names for a single {@code TimeZone}. * Each such row contains (with {@code i} ranging from * 0..n-1): *
serialVersionOnStream
* is written.
* @serial
* @since JDK1.1.4
*/
private int serialVersionOnStream = currentSerialVersion;
// END Android-added: Android specific serialization code.
// BEGIN Android-added: Support for tiny and standalone field names.
/**
* Tiny month strings; "J", "F", "M" etc.
*
* @serial
*/
private String[] tinyMonths;
/**
* Tiny weekday strings: "M", "F", "W" etc.
*
* @serial
*/
private String[] tinyWeekdays;
/**
* Standalone month strings; "January", "February", "March" etc.
*
* @serial
*/
private String[] standAloneMonths;
/**
* Short standalone month strings: "Jan", "Feb", "Mar" etc.
*
* @serial
*/
private String[] shortStandAloneMonths;
/**
* Tiny standalone month strings: "J", "F", "M" etc.
*
* @serial
*/
private String[] tinyStandAloneMonths;
/**
* Standalone weekday strings; "Monday", "Tuesday", "Wednesday" etc.
*
* @serial
*/
private String[] standAloneWeekdays;
/**
* Short standalone weekday strings; "Mon", "Tue", "Wed" etc.
*
* @serial
*/
private String[] shortStandAloneWeekdays;
/**
* Tiny standalone weekday strings; "M", "T", "W" etc.
*
* @serial
*/
private String[] tinyStandAloneWeekdays;
// END Android-added: Support for tiny and standalone field names.
// Android-changed: Removed reference to DateFormatSymbolsProvider.
/**
* Returns an array of all locales for which the
* {@code getInstance} methods of this class can return
* localized instances. It must contain at least a {@code Locale}
* instance equal to {@link java.util.Locale#US Locale.US}.
*
* @return An array of locales for which localized
* {@code DateFormatSymbols} instances are available.
* @since 1.6
*/
public static Locale[] getAvailableLocales() {
// Android-changed: No support for DateFormatSymbolsProvider.
return ICU.getAvailableLocales();
}
// Android-changed: Removed reference to DateFormatSymbolsProvider.
/**
* Gets the {@code DateFormatSymbols} instance for the default
* locale.
* This is equivalent to calling {@link #getInstance(Locale)
* getInstance(Locale.getDefault(Locale.Category.FORMAT))}.
* @see java.util.Locale#getDefault(java.util.Locale.Category)
* @see java.util.Locale.Category#FORMAT
* @return a {@code DateFormatSymbols} instance.
* @since 1.6
*/
public static final DateFormatSymbols getInstance() {
return getInstance(Locale.getDefault(Locale.Category.FORMAT));
}
// Android-changed: Removed reference to DateFormatSymbolsProvider.
/**
* Gets the {@code DateFormatSymbols} instance for the specified
* locale.
* @param locale the given locale.
* @return a {@code DateFormatSymbols} instance.
* @throws NullPointerException if {@code locale} is null
* @since 1.6
*/
public static final DateFormatSymbols getInstance(Locale locale) {
// Android-changed: Removed used of DateFormatSymbolsProvider.
return (DateFormatSymbols) getCachedInstance(locale).clone();
}
/**
* Returns a DateFormatSymbols provided by a provider or found in
* the cache. Note that this method returns a cached instance,
* not its clone. Therefore, the instance should never be given to
* an application.
*/
static final DateFormatSymbols getInstanceRef(Locale locale) {
// Android-changed: Removed used of DateFormatSymbolsProvider.
return getCachedInstance(locale);
}
// BEGIN Android-changed: Replace getProviderInstance() with getCachedInstance().
// Android removed support for DateFormatSymbolsProviders, but still caches DFS.
// App compat change for b/159514442.
/**
* Returns a cached DateFormatSymbols if it's found in the
* cache. Otherwise, this method returns a newly cached instance
* for the given locale.
*/
private static DateFormatSymbols getCachedInstance(Locale locale) {
Locale cacheKey = LocaleData.getCompatibleLocaleForBug159514442(locale);
SoftReference If the language requires different forms for formatting and
* stand-alone usages, this method returns month names in the
* formatting form. For example, the preferred month name for
* January in the Czech language is ledna in the
* formatting form, while it is leden in the stand-alone
* form. This method returns {@code "ledna"} in this case. Refer
* to the
* Calendar Elements in the Unicode Locale Data Markup Language
* (LDML) specification for more details.
*
* @implSpec This method returns 13 elements since
* {@link java.util.Calendar#UNDECIMBER Calendar.UNDECIMBER} is supported.
* @return the month strings.
*/
public String[] getMonths() {
return Arrays.copyOf(months, months.length);
}
/**
* Sets month strings. For example: "January", "February", etc.
* @param newMonths the new month strings. The array should
* be indexed by {@link java.util.Calendar#JANUARY Calendar.JANUARY},
* {@link java.util.Calendar#FEBRUARY Calendar.FEBRUARY}, etc.
*/
public void setMonths(String[] newMonths) {
months = Arrays.copyOf(newMonths, newMonths.length);
cachedHashCode = 0;
}
/**
* Gets short month strings. For example: "Jan", "Feb", etc.
* An array with either 12 or 13 elements will be returned depending
* on whether or not {@link java.util.Calendar#UNDECIMBER Calendar.UNDECIMBER}
* is supported. Use
* {@link java.util.Calendar#JANUARY Calendar.JANUARY},
* {@link java.util.Calendar#FEBRUARY Calendar.FEBRUARY},
* etc. to index the result array.
*
* If the language requires different forms for formatting and
* stand-alone usages, this method returns short month names in
* the formatting form. For example, the preferred abbreviation
* for January in the Catalan language is de gen. in the
* formatting form, while it is gen. in the stand-alone
* form. This method returns {@code "de gen."} in this case. Refer
* to the
* Calendar Elements in the Unicode Locale Data Markup Language
* (LDML) specification for more details.
*
* @implSpec This method returns 13 elements since
* {@link java.util.Calendar#UNDECIMBER Calendar.UNDECIMBER} is supported.
* @return the short month strings.
*/
public String[] getShortMonths() {
return Arrays.copyOf(shortMonths, shortMonths.length);
}
/**
* Sets short month strings. For example: "Jan", "Feb", etc.
* @param newShortMonths the new short month strings. The array should
* be indexed by {@link java.util.Calendar#JANUARY Calendar.JANUARY},
* {@link java.util.Calendar#FEBRUARY Calendar.FEBRUARY}, etc.
*/
public void setShortMonths(String[] newShortMonths) {
shortMonths = Arrays.copyOf(newShortMonths, newShortMonths.length);
cachedHashCode = 0;
}
/**
* Gets weekday strings. For example: "Sunday", "Monday", etc.
* @return the weekday strings. Use
* {@link java.util.Calendar#SUNDAY Calendar.SUNDAY},
* {@link java.util.Calendar#MONDAY Calendar.MONDAY}, etc. to index
* the result array.
*/
public String[] getWeekdays() {
return Arrays.copyOf(weekdays, weekdays.length);
}
/**
* Sets weekday strings. For example: "Sunday", "Monday", etc.
* @param newWeekdays the new weekday strings. The array should
* be indexed by {@link java.util.Calendar#SUNDAY Calendar.SUNDAY},
* {@link java.util.Calendar#MONDAY Calendar.MONDAY}, etc.
*/
public void setWeekdays(String[] newWeekdays) {
weekdays = Arrays.copyOf(newWeekdays, newWeekdays.length);
cachedHashCode = 0;
}
/**
* Gets short weekday strings. For example: "Sun", "Mon", etc.
* @return the short weekday strings. Use
* {@link java.util.Calendar#SUNDAY Calendar.SUNDAY},
* {@link java.util.Calendar#MONDAY Calendar.MONDAY}, etc. to index
* the result array.
*/
public String[] getShortWeekdays() {
return Arrays.copyOf(shortWeekdays, shortWeekdays.length);
}
/**
* Sets short weekday strings. For example: "Sun", "Mon", etc.
* @param newShortWeekdays the new short weekday strings. The array should
* be indexed by {@link java.util.Calendar#SUNDAY Calendar.SUNDAY},
* {@link java.util.Calendar#MONDAY Calendar.MONDAY}, etc.
*/
public void setShortWeekdays(String[] newShortWeekdays) {
shortWeekdays = Arrays.copyOf(newShortWeekdays, newShortWeekdays.length);
cachedHashCode = 0;
}
/**
* Gets ampm strings. For example: "AM" and "PM".
* @return the ampm strings.
*/
public String[] getAmPmStrings() {
return Arrays.copyOf(ampms, ampms.length);
}
/**
* Sets ampm strings. For example: "AM" and "PM".
* @param newAmpms the new ampm strings.
*/
public void setAmPmStrings(String[] newAmpms) {
ampms = Arrays.copyOf(newAmpms, newAmpms.length);
cachedHashCode = 0;
}
// Android-changed: Removed reference to TimeZoneNameProvider.
/**
* Gets time zone strings. Use of this method is discouraged; use
* {@link java.util.TimeZone#getDisplayName() TimeZone.getDisplayName()}
* instead.
*
* The value returned is a
* two-dimensional array of strings of size n by m,
* where m is at least 5. Each of the n rows is an
* entry containing the localized names for a single {@code TimeZone}.
* Each such row contains (with {@code i} ranging from
* 0..n-1):
*
* If {@link #setZoneStrings(String[][]) setZoneStrings} has been called
* on this {@code DateFormatSymbols} instance, then the strings
* provided by that call are returned. Otherwise, the returned array
* contains names provided by the runtime.
*
* @return the time zone strings.
* @see #setZoneStrings(String[][])
*/
public String[][] getZoneStrings() {
return getZoneStringsImpl(true);
}
/**
* Sets time zone strings. The argument must be a
* two-dimensional array of strings of size n by m,
* where m is at least 5. Each of the n rows is an
* entry containing the localized names for a single {@code TimeZone}.
* Each such row contains (with {@code i} ranging from
* 0..n-1):
*
*
* The zone ID is not localized; it's one of the valid IDs of
* the {@link java.util.TimeZone TimeZone} class that are not
* custom IDs.
* All other entries are localized names. If a zone does not implement
* daylight saving time, the daylight saving time names should not be used.
*
*
* The zone ID is not localized; it's one of the valid IDs of
* the {@link java.util.TimeZone TimeZone} class that are not
* custom IDs.
* All other entries are localized names.
*
* @param newZoneStrings the new time zone strings.
* @throws IllegalArgumentException if the length of any row in
* {@code newZoneStrings} is less than 5
* @throws NullPointerException if {@code newZoneStrings} is null
* @see #getZoneStrings()
*/
public void setZoneStrings(String[][] newZoneStrings) {
String[][] aCopy = new String[newZoneStrings.length][];
for (int i = 0; i < newZoneStrings.length; ++i) {
int len = newZoneStrings[i].length;
if (len < 5) {
throw new IllegalArgumentException();
}
aCopy[i] = Arrays.copyOf(newZoneStrings[i], len);
}
zoneStrings = aCopy;
isZoneStringsSet = true;
// Android-changed: don't include zone strings in hashCode to avoid populating it.
// cachedHashCode = 0;
}
/**
* Gets localized date-time pattern characters. For example: 'u', 't', etc.
* @return the localized date-time pattern characters.
*/
public String getLocalPatternChars() {
return localPatternChars;
}
/**
* Sets localized date-time pattern characters. For example: 'u', 't', etc.
* @param newLocalPatternChars the new localized date-time
* pattern characters.
*/
public void setLocalPatternChars(String newLocalPatternChars) {
// Call toString() to throw an NPE in case the argument is null
localPatternChars = newLocalPatternChars.toString();
cachedHashCode = 0;
}
// BEGIN Android-added: Support for tiny and standalone field names.
String[] getTinyMonths() {
return tinyMonths;
}
String[] getStandAloneMonths() {
return standAloneMonths;
}
String[] getShortStandAloneMonths() {
return shortStandAloneMonths;
}
String[] getTinyStandAloneMonths() {
return tinyStandAloneMonths;
}
String[] getTinyWeekdays() {
return tinyWeekdays;
}
String[] getStandAloneWeekdays() {
return standAloneWeekdays;
}
String[] getShortStandAloneWeekdays() {
return shortStandAloneWeekdays;
}
String[] getTinyStandAloneWeekdays() {
return tinyStandAloneWeekdays;
}
// END Android-added: Support for tiny and standalone field names.
/**
* Overrides Cloneable
*/
public Object clone()
{
try
{
DateFormatSymbols other = (DateFormatSymbols)super.clone();
copyMembers(this, other);
return other;
} catch (CloneNotSupportedException e) {
throw new InternalError(e);
}
}
/**
* Override hashCode.
* Generates a hash code for the DateFormatSymbols object.
*/
@Override
public int hashCode() {
int hashCode = cachedHashCode;
if (hashCode == 0) {
hashCode = 5;
hashCode = 11 * hashCode + Arrays.hashCode(eras);
hashCode = 11 * hashCode + Arrays.hashCode(months);
hashCode = 11 * hashCode + Arrays.hashCode(shortMonths);
hashCode = 11 * hashCode + Arrays.hashCode(weekdays);
hashCode = 11 * hashCode + Arrays.hashCode(shortWeekdays);
hashCode = 11 * hashCode + Arrays.hashCode(ampms);
// Android-changed: Don't include zone strings in hashCode to avoid populating it.
// hashCode = 11 * hashCode + Arrays.deepHashCode(getZoneStringsWrapper());
hashCode = 11 * hashCode + Objects.hashCode(localPatternChars);
if (hashCode != 0) {
cachedHashCode = hashCode;
}
}
return hashCode;
}
/**
* Override equals
*/
public boolean equals(Object obj)
{
if (this == obj) return true;
if (obj == null || getClass() != obj.getClass()) return false;
DateFormatSymbols that = (DateFormatSymbols) obj;
// BEGIN Android-changed: Avoid populating zoneStrings just for the comparison, add fields.
if (!(Arrays.equals(eras, that.eras)
&& Arrays.equals(months, that.months)
&& Arrays.equals(shortMonths, that.shortMonths)
&& Arrays.equals(tinyMonths, that.tinyMonths)
&& Arrays.equals(weekdays, that.weekdays)
&& Arrays.equals(shortWeekdays, that.shortWeekdays)
&& Arrays.equals(tinyWeekdays, that.tinyWeekdays)
&& Arrays.equals(standAloneMonths, that.standAloneMonths)
&& Arrays.equals(shortStandAloneMonths, that.shortStandAloneMonths)
&& Arrays.equals(tinyStandAloneMonths, that.tinyStandAloneMonths)
&& Arrays.equals(standAloneWeekdays, that.standAloneWeekdays)
&& Arrays.equals(shortStandAloneWeekdays, that.shortStandAloneWeekdays)
&& Arrays.equals(tinyStandAloneWeekdays, that.tinyStandAloneWeekdays)
&& Arrays.equals(ampms, that.ampms)
&& ((localPatternChars != null
&& localPatternChars.equals(that.localPatternChars))
|| (localPatternChars == null
&& that.localPatternChars == null)))) {
return false;
}
if (!isZoneStringsSet && !that.isZoneStringsSet && Objects.equals(locale, that.locale)) {
return true;
}
return Arrays.deepEquals(getZoneStringsWrapper(), that.getZoneStringsWrapper());
// END Android-changed: Avoid populating zoneStrings just for the comparison, add fields.
}
// =======================privates===============================
/**
* Useful constant for defining time zone offsets.
*/
static final int millisPerHour = 60*60*1000;
/**
* Cache to hold DateFormatSymbols instances per Locale.
*/
private static final ConcurrentMap