Explain the DateFormat and SimpleDateFormat classes of the formatted date in Java _java

DateFormat
1. DateFormat Introduction
The role of DateFormat is to format and parse the date/time. In fact, it is the date formatting tool that helps us format date and then converts date into the string string we want to use
However, the DateFormat format date has limited functionality and is not simpledateformat powerful, but DateFormat is SimpleDateFormat's parent class. Therefore, we first have a general understanding of DateFormat, and then learn SimpleDateFormat.
The role of DateFormat is to format date. It supports formatting styles including full, LONG, MEDIUM and short altogether 4 kinds:
(Dateformat.short)
Full of numbers, as 12.13.52 or 3:30pm
(Dateformat.medium)
Longer, such as the 12, 1952
(Dateformat.long)
Longer, such as January 12, 1952 or 3:30:32pm
(Dateformat.full)
is fully specified, such as Tuesday, April 12, 1952 AD, or 3:30:42pm PST.
The definition of DateFormat is as follows
Public abstract class NumberFormat extends Format {}
function interface of DateFormat
Default constructor:
DateFormat ()

Non-constructor:

Object          clone()
boolean         equals(Object object)
abstract StringBuffer  format(Date date, StringBuffer buffer, FieldPosition field)
final StringBuffer    format(Object object, StringBuffer buffer, FieldPosition field)
final String       format(Date date)
static Locale[]     getAvailableLocales()
Calendar         getCalendar()
final static DateFormat   getInstance()
final static DateFormat   getDateInstance()
final static DateFormat   getDateInstance(int style)
final static DateFormat   getDateInstance(int style, Locale locale)
final static DateFormat   getTimeInstance()
final static DateFormat   getTimeInstance(int style)
final static DateFormat   getTimeInstance(int style, Locale locale)
final static DateFormat   getDateTimeInstance()
final static DateFormat   getDateTimeInstance(int dateStyle, int timeStyle)
final static DateFormat   getDateTimeInstance(int dateStyle, int timeStyle, Locale locale)
NumberFormat   getNumberFormat()
TimeZone     getTimeZone()
int       hashCode()
boolean     isLenient()
Date       parse(String string)
abstract Date  parse(String string, ParsePosition position)
Object      parseObject(String string, ParsePosition position)
void       setCalendar(Calendar cal)
void       setLenient(boolean value)
void       setNumberFormat(NumberFormat format)
void       setTimeZone(TimeZone timezone)

Note: DateFormat is an abstract class.
When we get the DateFormat instance through the DateFormat getinstance (), Getdateinstance () and Getdatetimeinstance (), the SimpleDateFormat object is actually returned.
The following function is actually the returned SimpleDateFormat object.

Final static DateFormat getinstance () final static
DateFormat gettimeinstance ()
final static DateFormat gettimeinstance (int style)
final static dateformat gettimeinstance (int style, Locale Locale)
final static DateFormat getdateinstance ()
final static dateformat getdateinstance (int style)
final static DateFormat getdateinstance (int style, Locale Locale)
final static DateFormat getdatetimeinstance ()
final static DateFormat getdatetimeinstance (int datestyle, int timestyle)
final static dateformat getdatetimeinstance (int Datestyle, int timestyle, Locale Locale)

These functions are defined in Simpledateformat.java as follows:

public static final int FULL = 0;
public static final int LONG = 1;
public static final int MEDIUM = 2;
public static final int SHORT = 3;
public static final int DEFAULT = MEDIUM;

public final static DateFormat getInstance () {
  return getDateTimeInstance (SHORT, SHORT);
}

public final static DateFormat getTimeInstance ()
{
  return get (DEFAULT, 0, 1, Locale.getDefault ());
}

public final static DateFormat getTimeInstance (int style)
{
  return get (style, 0, 1, Locale.getDefault ());
}

public final static DateFormat getTimeInstance (int style,
                       Locale aLocale)
{
  return get (style, 0, 1, aLocale);
}

public final static DateFormat getDateInstance ()
{
  return get (0, DEFAULT, 2, Locale.getDefault ());
}

public final static DateFormat getDateInstance (int style)
{
  return get (0, style, 2, Locale.getDefault ());
}

public final static DateFormat getDateInstance (int style,
                       Locale aLocale)
{
  return get (0, style, 2, aLocale);
}

public final static DateFormat getDateTimeInstance ()
{
  return get (DEFAULT, DEFAULT, 3, Locale.getDefault ());
}

public final static DateFormat getDateTimeInstance (int dateStyle,
                          int timeStyle)
{
  return get (timeStyle, dateStyle, 3, Locale.getDefault ());
}

public final static DateFormat
  getDateTimeInstance (int dateStyle, int timeStyle, Locale aLocale)
{
  return get (timeStyle, dateStyle, 3, aLocale);
}

/ **
 * Obtaining a DateFormat instance is actually returning a SimpleDateFormat object.
 *
 * timeStyle-value can be "FULL" or "LONG" or "MEDIUM" or "SHORT"
 * dateStyle-value can be "FULL" or "LONG" or "MEDIUM" or "SHORT"
 * flags-The value can be "1" or "2" or "3".
 * 1 means get "time style"
 * 2 means get "date style"
 * 3 means get "time and date style"
 * loc-locale object, representing "local"
 * /
private static DateFormat get (int timeStyle, int dateStyle,
               int flags, Locale loc) {
  if ((flags & 1)! = 0) {
    if (timeStyle <0 || timeStyle> 3) {
      throw new IllegalArgumentException ("Illegal time style" + timeStyle);
    }
  } else {
    timeStyle = -1;
  }
  if ((flags & 2)! = 0) {
    if (dateStyle <0 || dateStyle> 3) {
      throw new IllegalArgumentException ("Illegal date style" + dateStyle);
    }
  } else {
    dateStyle = -1;
  }
  try {
    // Check whether a provider can provide an implementation that's closer
    // to the requested locale than what the Java runtime itself can provide.
    LocaleServiceProviderPool pool =
      LocaleServiceProviderPool.getPool (DateFormatProvider.class);
    if (pool.hasProviders ()) {
      DateFormat providersInstance = pool.getLocalizedObject (
                        DateFormatGetter.INSTANCE,
                        loc,
                        timeStyle,
                        dateStyle,
                        flags);
      if (providersInstance! = null) {
        return providersInstance;
      }
    }

    return new SimpleDateFormat (timeStyle, dateStyle, loc);
  } catch (MissingResourceException e) {
    return new SimpleDateFormat ("M / d / yy h: mm a");
  }
}

With the above code, we can further realize that the role of DateFormat is to format date, and help us convert date to the string string we need. DateFormat provides very limited functionality and can only support 4 formats such as full, LONG, MEDIUM, and short. Also, when we get the DateFormat instance, we are actually returning the SimpleDateFormat object.

2. DateFormat Example
below, we learn how to use DateFormat's common APIs through examples.
The source code is as follows (Dateformattest.java):

import java.util.Date;
import java.util.Locale;
import java.text.DateFormat;
import java.text.FieldPosition;

/ **
 * DateFormat API test program
 * /
public class DateFormatTest {

  public static void main (String [] args) {

    // Only show "time": call getTimeInstance () function
    testGetTimeInstance ();

    // Only show "date": call getDateInstance () function
    testGetDateInstance ();

    // Display "date" + "time": call getDateTimeInstance () function
    testGetDateTimeInstance ();

    // test the format () function
    testFormat ();
  }

  / **
   * Test DateFormat's getTimeInstance () function
   * It has 3 overloads:
   * (01) getTimeInstance ()
   * (02) getTimeInstance (int style)
   * (03) getTimeInstance (int style, Locale locale)
   *
   * @author skywang
   * /
  private static void testGetTimeInstance () {
    Date date = new Date ();

    // Locale locale = new Locale ("fr", "FR");
    Locale locale = new Locale ("zh", "CN");

    // equivalent to DateFormat.getTimeInstance (DateFormat.MEDIUM);
    DateFormat short0 = DateFormat.getTimeInstance ();

    // The parameter is: "Display style of time"
    DateFormat short1 = DateFormat.getTimeInstance (DateFormat.SHORT);
    DateFormat medium1 = DateFormat.getTimeInstance (DateFormat.MEDIUM);
    DateFormat long1 = DateFormat.getTimeInstance (DateFormat.LONG);
    DateFormat full1 = DateFormat.getTimeInstance (DateFormat.FULL);

    // The parameters are: "display style of time" and "region"
    DateFormat short2 = DateFormat.getTimeInstance (DateFormat.SHORT, locale);
    DateFormat medium2 = DateFormat.getTimeInstance (DateFormat.MEDIUM, locale);
    DateFormat long2 = DateFormat.getTimeInstance (DateFormat.LONG, locale);
    DateFormat full2 = DateFormat.getTimeInstance (DateFormat.FULL, locale);

    System.out.println ("\ n ---- getTimeInstance ---- \ n"
        + "(1.0) Empty Param:" + short0.format (date) + "\ n"
        + "(2.1) One Param (s):" + short1.format (date) + "\ n"
        + "(2.2) One Param (m):" + medium1.format (date) + "\ n"
        + "(2.3) One Param (l):" + long1.format (date) + "\ n"
        + "(2.4) One Param (f):" + full1.format (date) + "\ n"
        + "(3.1) One Param (s, l):" + short2.format (date) + "\ n"
        + "(3.2) One Param (m, l):" + medium2.format (date) + "\ n"
        + "(3.3) One Param (l, l):" + long2.format (date) + "\ n"
        + "(3.4) One Param (f, l):" + full2.format (date) + "\ n"
        );
  }

  / **
   * Test DateFormat's getDateTimeInstance () function
   * It has 3 overloads:
   * (01) getDateInstance ()
   * (02) getDateInstance (int style)
   * (03) getDateInstance (int style, Locale locale)
   * /
  public static void testGetDateTimeInstance () {
    Date date = new Date ();

    Locale locale = new Locale ("zh", "CN");

    // equivalent to DateFormat.getDateTimeInstance (DateFormat.MEDIUM);
    DateFormat short0 = DateFormat.getDateTimeInstance ();

    DateFormat short1 = DateFormat.getDateTimeInstance (DateFormat.SHORT, DateFormat.SHORT);
    DateFormat medium1 = DateFormat.getDateTimeInstance (DateFormat.MEDIUM, DateFormat.MEDIUM);
    DateFormat long1 = DateFormat.getDateTimeInstance (DateFormat.LONG, DateFormat.LONG);
    DateFormat full1 = DateFormat.getDateTimeInstance (DateFormat.FULL, DateFormat.FULL);

    DateFormat short2 = DateFormat.getDateTimeInstance (DateFormat.SHORT, DateFormat.SHORT, locale);
    DateFormat medium2 = DateFormat.getDateTimeInstance (DateFormat.MEDIUM, DateFormat.MEDIUM, locale);
    DateFormat long2 = DateFormat.getDateTimeInstance (DateFormat.LONG, DateFormat.LONG, locale);
    DateFormat full2 = DateFormat.getDateTimeInstance (DateFormat.FULL, DateFormat.FULL, locale);

    System.out.println ("\ n ---- getDateTimeInstance ---- \ n"
        + "(1.0) Empty Param:" + short0.format (date) + "\ n"
        + "(2.1) One Param (s):" + short1.format (date) + "\ n"
        + "(2.2) One Param (m):" + medium1.format (date) + "\ n"
        + "(2.3) One Param (l):" + long1.format (date) + "\ n"
        + "(2.4) One Param (f):" + full1.format (date) + "\ n"
        + "(3.1) One Param (s, l):" + short2.format (date) + "\ n"
        + "(3.2) One Param (m, l):" + medium2.format (date) + "\ n"
        + "(3.3) One Param (l, l):" + long2.format (date) + "\ n"
        + "(3.4) One Param (f, l):" + full2.format (date) + "\ n"
        );
  }

  / **
   * Test the DateFormat getDateInstance () function
   * It has 3 overloads:
   * (01) getDateTimeInstance ()
   * (02) getDateTimeInstance (int dateStyle, int timeStyle)
   * (03) getDateTimeInstance (int dateStyle, int timeStyle, Locale locale)
   * /
  public static void testGetDateInstance () {
    Date date = new Date ();

    // Locale locale = new Locale ("en", "US");
    Locale locale = new Locale ("zh", "CN");

    // equivalent to DateFormat.getDateInstance (DateFormat.MEDIUM);
    DateFormat short0 = DateFormat.getDateInstance ();

    DateFormat short1 = DateFormat.getDateInstance (DateFormat.SHORT);
    DateFormat medium1 = DateFormat.getDateInstance (DateFormat.MEDIUM);
    DateFormat long1 = DateFormat.getDateInstance (DateFormat.LONG);
    DateFormat full1 = DateFormat.getDateInstance (DateFormat.FULL);

    DateFormat short2 = DateFormat.getDateInstance (DateFormat.SHORT, locale);

DateFormat medium2 = DateFormat.getDateInstance (DateFormat.MEDIUM, locale);
    DateFormat long2 = DateFormat.getDateInstance (DateFormat.LONG, locale);
    DateFormat full2 = DateFormat.getDateInstance (DateFormat.FULL, locale);

    System.out.println ("\ n ---- getDateInstance ---- \ n"
        + "(1.0) Empty Param:" + short0.format (date) + "\ n"
        + "(2.1) One Param (s):" + short1.format (date) + "\ n"
        + "(2.2) One Param (m):" + medium1.format (date) + "\ n"
        + "(2.3) One Param (l):" + long1.format (date) + "\ n"
        + "(2.4) One Param (f):" + full1.format (date) + "\ n"
        + "(3.1) One Param (s, l):" + short2.format (date) + "\ n"
        + "(3.2) One Param (m, l):" + medium2.format (date) + "\ n"
        + "(3.3) One Param (l, l):" + long2.format (date) + "\ n"
        + "(3.4) One Param (f, l):" + full2.format (date) + "\ n"
        );

  }

  / **
   * Test DateFormat's format () function
   * /
  public static void testFormat () {
    Date date = new Date ();
    StringBuffer sb = new StringBuffer ();
    FieldPosition field = new FieldPosition (DateFormat.YEAR_FIELD);
    DateFormat format = DateFormat.getDateTimeInstance ();

    sb = format.format (date, sb, field);
    System.out.println ("\ ntestFormat");
    System.out.printf ("sb =% s \ n", sb);
  }
}

Run Result:

----gettimeinstance----(1.0) Empty param:4:54:22 pm (2.1) One Param (s): 4:54 pm (2.2) One Param (m): 4:54:22 PM (2. 3 One Param (l): 4:54:22 PM CST (2.4) one Param (f): 4:54:22 PM CST (3.1) One Param (s,l): PM 4:54 (3.2) one Param (m,l): 16   : 54:22 (3.3) One Param (l,l): 04:54 P.M. 22 seconds (3.4) one Param (f,l): 04:54 P.M. 22 sec CST----getdateinstance----(1.0) Empty Param : 2.1 One Param (s): 1/23/14 (2.2) One Param (m): 2014, 2014 (2.3) one Param (L): January 23, 2014 (2.4 One Param (f): Thursday, January, 2014 (3.1) one Param (s,l): 14-1-23 (3.2) one Param (m,l): 2014-1-23 (3.3) One Param ( L,L): January 23, 2014 (3.4) one Param (f,l): January 23, 2014 Thursday----getdatetimeinstance----(1.0) Empty Param:jan 23, 2014 4:54 : PM (2.1) One Param (s): 1/23/14 4:54 pm (2.2) One Param (m): A few, 2014 4:54:23 PM (2.3) one Param (L): January 23, 2014 4:54:23 PM CST (2.4) one Param (f): Thursday, January, 2014 4:54:23 PM CST (3.1) One Param (s,l): 14-1-23 4:54 (3 .2) One Param (m,l): 2014-1-23 16:54:23 (3.3) One Param (l,l): January 23, 2014 04:54 P.M. 23 SEC (3.4) one Param (f,l): January 23, 2014 Thursday 04:54 P.M. 23 sec CST Testfor

 Mat Sb=jan, 2014 4:54:23 PM

Ok. At this point, the study of DateFormat ends. Next, we begin to learn SimpleDateFormat, which is what formatting date needs to be focused on.

SimpleDateFormat
1. SimpleDateFormat Introduction
SimpleDateFormat is a tool that formats date and parses date strings. Its most common use is to format date in the specified format, and then we use the string that can be obtained after the date is formatted.
More strictly speaking, SimpleDateFormat is a specific class that formats and parses dates in a way that is relevant to the locale. It allows for formatting (date-> text), parsing (text-> date), and normalization.
The SimpleDateFormat constructor:
Constructors

SimpleDateFormat ()
SimpleDateFormat (string pattern)
SimpleDateFormat (string template, DateFormatSymbols Value)
SimpleDateFormat (String template, Locale Locale)

Non-constructor function

void               Applylocalizedpattern (string template)
void               Applypattern (string template)
Object              Clone (
boolean             equals (object)
stringbuffer           Format (date date, StringBuffer buffer, fieldposition Fieldpos)
attributedcharacteriterator   Formattocharacteriterator (Object object)
Date               Get2digityearstart ()
dateformatsymbols        getdateformatsymbols ()
int               hashcode ()
Date               Parse (string string, parseposition position)
void               Set2digityearstart (date date)
void               Setdateformatsymbols (dateformatsymbols value)
string              tolocalizedpattern ()
string              topattern ( )

SimpleDateFormat Simple demonstration:

Creates a new Date object with the time 2013-09-19
date = new Date (113,8,19); 
Create a new "SimpleDateFormat object" and set the SDF's "format mode"
simpledateformat sdf = new SimpleDateFormat ("Yyyy-mm-dd");
Formats date with SDF and returns a string.
String str = sdf.format (date); 

2. SimpleDateFormat Related Format description
2.1 Date and time patterns
date and time formats are specified by date and time pattern strings. In a date and time pattern string, the unnamed letters ' a ' to ' Z ' and ' a ' to ' Z ' are interpreted as pattern letters, which are used to represent a date or time string element. The text can be enclosed in single quotes (') to avoid interpretation. "" "represents single quotes. All other characters are not interpreted; they are simply copied to the output string when they are formatted, or they match the input string when parsing.
The following pattern letters are defined (all other characters ' a ' to ' Z ' and ' a ' to ' Z ' are preserved):

-->-->

Letters	Date or time element	Said	Example
G	Era Marker	Text	AD
Y	Years	Year	1996; 96
M	Months of the year	Month	July; June June; 07
W	Number of weeks in the year	Number	27
W	Number of weeks in the month	Number	2
D	Days in the year	Number	189
D	Days in the month	Number	10
F	Weeks in the month	Number	2
E	Days in the week	Text	Tuesday; Tue
A	AM/PM Mark	Text	Pm
H	Number of hours in a day (0-23)	Number	0
K	Number of hours in a day (1-24)	Number	24
K	Number of hours in am/pm (0-11)	Number	0
H	Number of hours in am/pm (1-12)	Number	12
M	Number of minutes in the hour	Number	30
S	Number of seconds in minutes	Number	55
S	Number of milliseconds	Number	978
Z	Time	General Time Zone	Pacific Standard time; PST; gmt-08:00
Z	Time	RFC 822 Time Zone	-0800

The pattern letters are usually repeated, and their number determines their exact representation:


Text: For formatting, if the number of pattern letters is greater than or equal to 4, the full form is used, otherwise the short form or abbreviated form is used when available. For parsing, both forms are acceptable, regardless of the number of pattern letters.


Number: For formatting, the quantity of the pattern letters is the smallest digit, and if the digits are not enough, fill them with 0 to achieve this number. For parsing, the number of pattern letters is ignored unless two contiguous fields must be separated.


Year: If the calendar for the formatter is the Gregorian calendar, the following rules apply.


Month: If the number of pattern letters is 3 or greater than 3, the month is interpreted as text;


For formatting, if the number of pattern letters is 2, the year is truncated to 2 digits, otherwise the year is interpreted to number.


For parsing, if the number of pattern letters is greater than 2, the year is interpreted literally, regardless of the number of digits. So use the pattern "mm/dd/yyyy" to parse "01/11/12" to January 11, 12 A.D.


When parsing the abbreviated year pattern ("Y" or "yy"), the SimpleDateFormat must interpret the abbreviated year relative to a century. This is accomplished by adjusting the date to the 80 and beyond 20 before the SimpleDateFormat instance was created. For example, in "Mm/dd/yy" mode, if the SimpleDateFormat instance was created on January 1, 1997, the string "01/11/12" will be interpreted as January 11, 2012, and the string "05/04/64" will be interpreted as May 4, 1964. When parsing, only strings consisting of exactly two digits (as defined by Character#isdigit (char)) are resolved to the default century. Any other numeric string will be interpreted literally, such as a single digit string, a string of 3 or more digits, or a two-bit numeric string that is not a number (for example, "1"). Therefore, in the same mode, "01/02/3" or "01/02/003" is interpreted as A.D. January 2, 3. Similarly, the "01/02/-3" resolution was January 2, 4 BC.


Otherwise, the calendar system-specific form is applied. For formatting and parsing, if the number of pattern letters is 4 or greater than 4, the calendar-specific long form is used. Otherwise, the calendar-specific short or abbreviated form is used.


SimpleDateFormat also supports localized date and time pattern strings. In these strings, the pattern letters described above can be replaced with other language-related pattern letters. SimpleDateFormat does not handle text localization other than the schema letter, which is handled by the client of the class.


Example


The following example shows how to interpret date and time patterns in the U.S. language environment. The given date and time is 2001-07-04 12:08:56 for the Pacific Time zone in the United States.


-->

Date and time patterns	Results
"YYYY. Mm.dd G ' at ' HH:mm:ss z '	2001.07.04 AD at 12:08:56 PDT
"EEE, MMM D, ' yy"	Wed, April 4, ' 01
"H:mm a"	12:08 PM
"HH ' o ' clock ' A, zzzz"	O ' clock PM, Pacific Daylight Time
"K:mm A, z"	0:08 PM, PDT
"Yyyyy. MMMMM.DD GGG hh:mm AAA "	02001.july.04 AD 12:08 PM
"EEE, D MMM yyyy HH:mm:ss Z"	Wed, 4 June 2001 12:08:56-0700
"Yymmddhhmmssz"	010704120856-0700
"Yyyy-mm-dd ' T ' HH:mm:ss." Sssz "	2001-07-04t12:08:56.235-0700

The date format is not synchronized. It is recommended that you create separate format instances for each thread. If more than one thread accesses a format at the same time, it must be externally synchronized.


3. SimpleDateFormat sample
Below, we learn how to use SimpleDateFormat through an example.


The source code is as follows (Simpledateformattest.java):

import java.util.Date;
import java.util.Locale;
import java.util.Calendar;
import java.text.DateFormat;
import java.text.SimpleDateFormat;

/ **
 * SimpleDateFormat API test program
 *
 * @author skywang
 * @email kuiwu-wang@163.com
 * /
public class SimpleDateFormatTest {

  public static void main (String [] args) {

    // Get date / time through SimpleDateFormat: there are multiple formats
    testSimpleDateFormats ();

    // Get Date / Time via DateFormat
    superTest ();
  }

  / **
   * Get Date / Time via SimpleDateFormat. There are multiple formats to choose from
   * /
  private static void testSimpleDateFormats () {
    String [] formats = new String [] {
      "HH: mm", // 14:22
      "h: mm a", // 2:22 pm
      "HH: mm z", // 14:22 CST
      "HH: mm Z", // 14:22 +0800
      "HH: mm zzzz", // 14:22 China Standard Time
      "HH: mm: ss", // 14:22:30
      "yyyy-MM-dd", // 2013-09-19
      "yyyy-MM-dd HH: mm", // 2013-09-19 14:22
      "yyyy-MM-dd HH: mm: ss", // 2013-09-19 14:22:30
      "yyyy-MM-dd HH: mm: ss zzzz", // 2013-09-19 14:22:30 China Standard Time
      "EEEE yyyy-MM-dd HH: mm: ss zzzz", // Thursday 2013-09-19 14:22:30 China Standard Time
      "yyyy-MM-dd HH: mm: ss.SSSZ", // 2013-09-19 14: 22: 30.000 + 0800
      "yyyy-MM-dd'T'HH: mm: ss.SSSZ", // 2013-09-19T14: 22: 30.000 + 0800
      "yyyy.MM.dd G 'at' HH: mm: ss z", // 2013.09.19 AD at 14:22:30 CST
      "K: mm a", // 2:22 pm, CST
      "EEE, MMM d, '' yy", // Thursday, September 19, '13
      "hh 'o''clock' a, zzzz", // 02 o'clock afternoon, China Standard Time
      "yyyyy.MMMMM.dd GGG hh: mm aaa", // 02013. September. 19 AD 02:22 PM
      "EEE, d MMM yyyy HH: mm: ss Z", // Thursday, 19 September 2013 14:22:30 +0800
      "yyMMddHHmmssZ", // 130919142230 + 0800
      "yyyy-MM-dd'T'HH: mm: ss.SSSZ", // 2013-09-19T14: 22: 30.000 + 0800
      "EEEE 'DATE (' yyyy-MM-dd ')' 'TIME (' HH: mm: ss ')' zzzz", // Thursday 2013-09-19 14:22:30 Standard Time
    };

    // Date date = (new Date (0)); // date is 1970-01-01 07:00:00
    // Date date = Calendar.getInstance (). GetTime (); // date is the current time
    Date date = new Date (113, 8, 19, 14, 22, 30); // date is 2013-09-19 14:22:30
    for (String format: formats) {
      SimpleDateFormat sdf = new SimpleDateFormat (format, Locale.SIMPLIFIED_CHINESE);
      // SimpleDateFormat sdf = new SimpleDateFormat (format);
      System.out.format ("% 30s% s \ n", format, sdf.format (date));
     }
  }

  / **
   * Get Date / Time via DateFormat
   * /
  private static void superTest () {
    // Create a new date object, the time is 2013-09-19 14:22:30
    // (01) year = "'target year'-1900",
    // (02) months. 0 is January, 1 is February, and so on.
    // (03) days. Numbers between 1-31
    Date mDate = new Date (113, 8, 19, 14, 22, 30);
    Locale locale = new Locale ("zh", "CN");

    // 14:22:30
    String time = DateFormat.getTimeInstance (DateFormat.MEDIUM, Locale.SIMPLIFIED_CHINESE) .format (mDate);
    // 2013-09-19
    String date = DateFormat.getDateInstance (DateFormat.MEDIUM, Locale.SIMPLIFIED_CHINESE) .format (mDate);
    // 2013-09-19 14:22:30
    String datetime = DateFormat.getDateTimeInstance (DateFormat.MEDIUM, DateFormat.MEDIUM, Locale.SIMPLIFIED_CHINESE) .format (mDate);

    System.out.printf ("\ ntime =% s \ ndate =% s \ ndatetime =% s \ n", time, date, datetime);
  }
}

Run Result:

HH: mm 14:22
            h: mm a 2:22 pm
            HH: mm z 14:22 CST
            HH: mm Z 14:22 +0800
          HH: mm zzzz 14:22 China Standard Time
           HH: mm: ss 14:22:30
          yyyy-MM-dd 2013-09-19
       yyyy-MM-dd HH: mm 2013-09-19 14:22
      yyyy-MM-dd HH: mm: ss 2013-09-19 14:22:30
   yyyy-MM-dd HH: mm: ss zzzz 2013-09-19 14:22:30 China Standard Time
 EEEE yyyy-MM-dd HH: mm: ss zzzz Thursday 2013-09-19 14:22:30 China Standard Time
   yyyy-MM-dd HH: mm: ss.SSSZ 2013-09-19 14: 22: 30.000 + 0800
  yyyy-MM-dd'T'HH: mm: ss.SSSZ 2013-09-19T14: 22: 30.000 + 0800
 yyyy.MM.dd G 'at' HH: mm: ss z 2013.09.19 AD at 14:22:30 CST
            K: mm a 2:22 pm
       EEE, MMM d, '' yy Thursday, September 19, '13
     hh 'o''clock' a, zzzz 02 o'clock afternoon, China Standard Time
 yyyyy.MMMMM.dd GGG hh: mm aaa 02013. September. 19 AD 02:22 PM
  EEE, d MMM yyyy HH: mm: ss Z Thursday, 19 September 2013 14:22:30 +0800
         yyMMddHHmmssZ 130919142230 + 0800
  yyyy-MM-dd'T'HH: mm: ss.SSSZ 2013-09-19T14: 22: 30.000 + 0800
EEEE 'DATE (' yyyy-MM-dd ')' 'TIME (' HH: mm: ss ')' zzzz Thursday DATE (2013-09-19) TIME (14:22:30) China Standard Time

time = 14: 22: 30
date = 2013-9-19
datetime = 2013-9-19 14:22:30