Date and time formatters are used to convert dates and times from their internal representations to textual form and back again in a language-independent manner. The date and time formatters use UDate, which is the internal representation. Converting from the internal representation (milliseconds since midnight, January 1, 1970) to text is known as "formatting," and converting from text to milliseconds is known as "parsing." These processes involve two mappings:
DateFormat helps format and parse dates for any locale. Your code can be completely independent of the locale conventions for months, days of the week, or calendar format.
The DateFormat interface in ICU enables you to format a Date in milliseconds into a string representation of the date. It also parses the string back to the internal Date representation in milliseconds.
To format a date for a different Locale, specify it in the call to:
Use a DateFormat to parse also:
When numeric fields abut one another directly, with no intervening delimiter characters, they constitute a run of abutting numeric fields. Such runs are parsed specially. For example, the format "HHmmss" parses the input text "123456" to 12:34:56, parses the input text "12345" to 1:23:45, and fails to parse "1234". In other words, the leftmost field of the run is flexible, while the others keep a fixed width. If the parse fails anywhere in the run, then the leftmost field is shortened by one character, and the entire run is parsed again. This is repeated until either the parse succeeds or the leftmost field is one character in length. If the parse still fails at that point, the parse of the run fails.
Use createDateInstance to produce the normal date format for that country. There are other static factory methods available. Use createTimeInstance to produce the normal time format for that country. Use createDateTimeInstance to produce a DateFormat that formats both date and time. You can pass different options to these factory methods to control the length of the result; from SHORT to MEDIUM to LONG to FULL. The exact result depends on the locale, but generally:
For more general flexibility, the DateTimePatternGenerator can map a custom selection of time and date fields, along with various display styles for those fields, to a locale-appropriate format that can then be set as the format to use by the DateFormat.
ICU currently provides limited support for formatting dates using a “relative” style, specified using RELATIVE_SHORT, RELATIVE_MEDIUM, RELATIVE_LONG. or RELATIVE_FULL. As currently implemented, relative date formatting only affects the formatting of dates within a limited range of calendar days before or after the current date, based on the CLDR <field type="day">/<relative> data: For example, in English, "Yesterday", "Today", and "Tomorrow". Within this range, the specific relative style currently makes no difference. Outside of this range, relative dates are formatted using the corresponding non-relative style (SHORT, MEDIUM, etc.). Relative time styles are not currently supported, and behave just like the corresponding non-relative style.
You can set the time zone on the format. If you want more control over the format or parsing, cast the DateFormat you get from the factory methods to a SimpleDateFormat. This works for the majority of countries.
You can also use forms of the parse and format methods with ParsePosition and FieldPosition to enable you to:
SimpleDateFormat is a concrete class used for formatting and parsing dates in a language-independent manner. It allows for formatting, parsing, and normalization. It formats or parses a date or time, which is the standard milliseconds since 24:00 GMT, Jan. 1, 1970.
SimpleDateFormat is the only built-in implementation of DateFormat. It provides a programmable interface that can be used to produce formatted dates and times in a wide variety of formats. The formats include almost all of the most common ones.
Create a date-time formatter using the following methods rather than constructing an instance of SimpleDateFormat. In this way, the program is guaranteed to get an appropriate formatting pattern of the locale.
If you need a more unusual pattern, construct a SimpleDateFormat directly and give it an appropriate pattern.
A date pattern is a string of characters, where specific strings of characters are replaced with date and time data from a calendar when formatting or used to generate data for a calendar when parsing.
The Date Field Symbol Table below contains the characters used in patterns to show the appropriate formats for a given locale, such as yyyy for the year. Characters may be used multiple times. For example, if y is used for the year, 'yy' might produce '99', whereas 'yyyy' produces '1999'. For most numerical fields, the number of characters specifies the field width. For example, if h is the hour, 'h' might produce '5', but 'hh' produces '05'. For some characters, the count specifies whether an abbreviated or full form should be used, but may have other choices, as given below.
Two single quotes represents a literal single quote, either inside or outside single quotes. Text within single quotes is not interpreted in any way (except for two adjacent single quotes). Otherwise all ASCII letter from a to z and A to Z are reserved as syntax characters, and require quoting if they are to represent literal characters. In addition, certain ASCII punctuation characters may become variable in the future (eg ":" being interpreted as the time separator and '/' as a date separator, and replaced by respective locale-sensitive characters in display).
"Stand Alone" values refer to those designed to stand on their own, as opposed to being with other formatted values. "2nd quarter" would use the stand alone format (QQQQ), whereas "2nd quarter 2007" would use the regular format (qqqq yyyy).
The pattern characters used in the Date Field Symbol Table are defined by CLDR; for more information see CLDR Date Field SymbolTable. Note that the examples may not reflect current CLDR data.
ICU supports time zone display names defined by the LDML (Unicode Locale Data Markup Language ) specification. Since ICU 3.8, the vast majority of localized time zone names are no longer associated with individual time zones. Instead, a set of localized time zone names are associated with a metazone and one or more individual time zones are mapped to the same metazone. For example, metazone “America_Pacific” has its own display name data such as “PST” “PDT” “PT” “Pacific Standard Time” “Pacific Daylight Time” “Pacific Time” and these names are shared by multiple individual time zones “America/Los_Angeles”, “America/Vancouver”, “America/Tijuana” and so on. The mapping from individual time zone to metazone is not a simple 1-to-1 mapping, but it changes time to time. For example, time zone “America/Indiana/Tell_City” uses name data from metazone “America_Eastern” until April 2, 2006, but it changes to metazone “America_Central” after the date. So the display name used for “America/Indiana/Tell_City” before the date (e.g. “Eastern Time”) differs from the one after the date (e.g. “Central Time).
There are several different display name types available in the LDML specification.
Each format type in the above table is used as a primary type or a fallback in SimpleDateFormat. The table below explains how ICU time zone format pattern work and its characteristics.
* At a transition from daylight saving time to standard time, there is a wall time interval occurs twice.
The DateTimePatternGenerator class provides a way to map a request for a set of date/time fields, along with their width, to a locale-appropriate format pattern. The request is in the form of a “skeleton” which just contains pattern letters for the desired fields using the representation for the desired width. In a skeleton, anything other than a pattern letter is ignored, field order is insignificant, and there are two special additional pattern letters that may be used: 'j' requests the preferred hour-cycle type for the locale (it gets mapped to one of 'H', 'h', 'k', or 'K'); 'J' is similar but requests no AM/PM marker even if the locale’s preferred hour-cycle type is 'h' or 'K'.
For example, a skeleton of “MMMMdjmm” might result in the following format patterns for different locales:
The most important DateTimePatternGenerator methods are the varieties of getBestPattern.
Note that the fields in the format pattern may be adjusted as appropriate for the locale and may not exactly match those in the skeleton. For example:
DateFormatSymbols is a public class for encapsulating localizable date-time formatting data, including time zone data. DateFormatSymbols is used by DateFormat and SimpleDateFormat.
DateFormatSymbols specifies the exact character strings to use for various parts of a date or time For example, the names of the months and days of the week, the strings for AM and PM and the day of the week considered to be the first day of the week (used in drawing calendar grids) are controlled by DateFormatSymbols.
Create a date-time formatter using the createTimeInstance, createDateInstance, or createDateTimeInstance methods in DateFormat. Each of these methods can return a date/time formatter initialized with a default format pattern, along with the date-time formatting data for a given or default locale. After a formatter is created, modify the format pattern using applyPattern.
If you want to create a date-time formatter with a particular format pattern and locale, use one of the SimpleDateFormat constructors:
This loads the appropriate date-time formatting data from the locale.s