Java中日期和時間的處理原理解析

日期和時間的處理不僅在面試題中會考到，在實際項目開發中也是我們經常需要處理的問題，似乎沒有哪個項目可以避開它們，我們常常在處理用戶的出生年月日、註冊日期，訂單的創建時間等屬性時用到，由此可見其重要性。 

提到日期和時間，我想大家最先想到應該是java.util.Date類吧。Date類可以精確到毫秒數，這個毫秒數是相對於格林威治標準時間“1970-01-01 00:00:00.000 GMT”的差值。那麼，什麼是格林威治標準時間呢？要回答這個問題，我們需要先來了解一下世界時間標準方面的知識。 

世界時間標準主要有UTC，即Coordinated Universal Time（中文名譯作世界協調時間、世界統一時間或世界標準時間），以及GMT，即Greenwich Mean Time（中文名譯作格林威治標準時間或格林威治平均時間）兩種。嚴格來講，UTC比GMT更加精確一些，不過它們的差值不會超過0.9秒，如果超過了，將會爲UTC增加閏秒以與GMT，也就是地球自轉週期保持一致。所以在日常使用中，我們可以把UTC和GMT一樣看待。 

日期和時間的表示是與我們所處的時區相關聯的，如果我們不指定時區，那麼它們將以系統默認的時區來顯示。我們先來看看如何創建日期對象。Date類有很多個構造器方法，大部分已經不被贊成使用了（Deprecated），不過還剩下兩個可以使用的： 

public Date() {
    this(System.currentTimeMillis());
}

public Date(long date) {
    //other code
}

第一個是無參構造器，使用系統當前時間的毫秒數來創建Date對象，它調用了java.lang.System類的currentTimeMillis()來取得系統的當前時間的毫秒值。這是個本地方法，它的定義如下： 

public static native long currentTimeMillis();

第二個構造器是根據給定的毫秒數來創建一個與之對應的Date對象，這個毫秒數決定了被創建對象的年、月、日、時、分、秒屬性的值。 

我們來看看日期和時間在默認時區下的顯示效果： 

import java.util.Date;

public class DateTest {
    public static void main(String[] args) {
        Date d = new Date();
        // 在默認時區下輸出日期和時間值
        System.out.println(d);
    }
}

運行結果： 

• Tue Jul 22 10:44:47 CST 2008

大家應該注意到了年份前的“CST”標識，它是China Standard Time的縮寫，指的是中國標準時間，也就是我們常說的北京時間。它與UTC的時差是UTC+8:00，就是說北京時間比世界標準時間早8個小時，如果世界標準時間是早上1點，北京時間就是早上9點。一般情況下我們不需要關心時區問題。 

在創建完Date對象之後，我們可以通過調用getTime()方法來獲得該對象的毫秒數值，調用setTime(long time)方法來設置它的毫秒數值，從而影響年、月、日、時、分、秒這些屬性。這兩個方法的定義如下： 

public long getTime() {
    //other code
}

public void setTime(long time) {
    //other code
}

既然Date對象可以表示盛相對於“1970-01-01 00:00:00.000 GMT”的毫秒數，我們自然可以通過這個值來比較兩個日期的大小了，不過對於日期來講，前後的說法應該更爲恰當。而Date類已經爲我們提供了這樣的方法： 

public boolean before(Date when) {
    //other code
}

public boolean after(Date when) {
    //other code
}

public int compareTo(Date anotherDate) {
    //other code
}

before()是判斷當前日期是否在參數日期之前，即當前日期毫秒數小於參數日期毫秒數；after()是判斷當前日期是否在參數日期之後，即當前日期毫秒數大於參數日期毫秒數。而compareTo()是將當前日期與參數日期比較後，返回一個int型值，它的返回值有三種可能：-1、0和1。如果返回-1則表示當前日期在參數日期之前；如果返回0則表示兩個日期是同一時刻；返回1則表示當前日期在參數日期之後。雖然我們可以用compareTo()方法來比較兩個Date對象，但是它的設計實際是另有用途的，我們在後面的章節將會講到。 

下面我們就用一個示例來檢驗一下以上方法的用法： 

import java.util.Date;

public class DateTest {
    public static void main(String[] args) {
        // 2008-08-08 20:00:00對應的毫秒數
        long t2008 = 1218196800000L;
        // 1900-01-01 20:00:00對應的毫秒數
        long t1900 = -2208945952000L;

        // 指定毫秒數創建Date對象
        Date d2008 = new Date(t2008);
        // 使用系統默認時間創建Date對象
        Date d1900 = new Date();
        // 通過設置毫秒數改變日期和時間
        d1900.setTime(t1900);

        System.out.println("調用方法：d1900.before(d2008)");
        System.out
                .print("比較結果：\"1900-01-01 20:00:00\"在\"2008-08-08 20:00:00\"");
        // 使用before()方法比較
        if (d1900.before(d2008)) {
            System.out.println("之前");
        } else {
            System.out.println("之後");
        }

        System.out.println();

        System.out.println("調用方法：d2008.after(d1900)");
        System.out
                .print("比較結果：\"2008-08-08 20:00:00\"在\"1900-01-01 20:00:00\"");
        // 使用before()方法比較
        if (d2008.after(d1900)) {
            System.out.println("之後");
        } else {
            System.out.println("之前");
        }

        System.out.println();

        System.out.println("調用方法：d1900.compareTo(d2008)");
        System.out
                .print("比較結果：\"1900-01-01 20:00:00\"在\"2008-08-08 20:00:00\"");
        // 使用compareTo()方法比較
        int i = d1900.compareTo(d2008);
        if (i == -1) {
            System.out.println("之前");
        } else if (i == 1) {
            System.out.println("之後");
        } else if (i == 0) {
            System.out.println("是同一時刻");
        }
    }
}

運行結果： 

1. 調用方法：d1900.before(d2008)
2. 比較結果："1900-01-01 20:00:00"在"2008-08-08 20:00:00"之前
4. 調用方法：d2008.after(d1900)
5. 比較結果："2008-08-08 20:00:00"在"1900-01-01 20:00:00"之後
7. 調用方法：d1900.compareTo(d2008)
8. 比較結果："1900-01-01 20:00:00"在"2008-08-08 20:00:00"之前

那麼如果我們想直接獲取或者改變年、月、日、時、分、秒等等這些屬性的值時怎麼辦呢？Date類當然有完成這些操作的方法，不過遺憾的是它們也都已經不被贊成使用了。我們必須換一個能夠提供這些操作的類，這個類就是java.util.Calendar。 

Calendar是一個抽象類，我們無法直接實例化它，它有一個具體子類實體類java.util.GregorianCalendar，這個類實現的就是我們日常所用的公曆曆法，或者叫做陽曆。我們可以直接使用new命令創建它的實例，或者使用Calendar類的這個方法來獲得它實例： 

public static Calendar getInstance(){
    //other code
}

採用上面這個方法時，我們創建的Calendar對象的日期和時間值是對象被創建時系統日期和時間值。當使用new命令時，我們有兩種選擇，一種是使用系統當前的日期和時間值初始化GregorianCalendar對象；另一種是通過給定年、月、日、時、分、秒等屬性值來對其進行初始化。請看下面的例子： 

import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.GregorianCalendar;

public class DateTest {
    /**
     * 以一種較爲友好的方式格式化日期時間值
     *
     * @param c
     *            日期時間對象
     * @return 格式化後的日期時間字符串
     */
    public static String toFriendlyString(Calendar c) {
        if (c != null) {
            DateFormat df = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss");
            return df.format(c.getTime());
        }
        return null;
    }

    public static void main(String[] args) {
        Calendar c1 = Calendar.getInstance();
        System.out.println("創建方式：Calendar.getInstance()");
        System.out.println("日期時間：" + DateTest.toFriendlyString(c1));
        System.out.println();

        Calendar c2 = new GregorianCalendar();
        System.out.println("創建方式：new GregorianCalendar()");
        System.out.println("日期時間：" + DateTest.toFriendlyString(c2));
        System.out.println();

        // 參數含義依次爲：年、月、日
        Calendar c3 = new GregorianCalendar(2008, 8, 8);
        System.out.println("創建方式：new GregorianCalendar(2008, 8, 8)");
        System.out.println("日期時間：" + DateTest.toFriendlyString(c3));
        System.out.println();

        // 參數含義依次爲：年、月、日、時、分
        Calendar c4 = new GregorianCalendar(2008, 8, 8, 6, 10);
        System.out.println("創建方式：new GregorianCalendar(2008, 8, 8, 6, 10)");
        System.out.println("日期時間：" + DateTest.toFriendlyString(c4));
        System.out.println();

        // 參數含義依次爲：年、月、日、時、分、秒
        Calendar c5 = new GregorianCalendar(2008, 8, 8, 18, 10, 5);
        System.out.println("創建方式：new GregorianCalendar(2008, 8, 8, 18, 10, 5)");
        System.out.println("日期時間：" + DateTest.toFriendlyString(c5));
    }
}

運行結果如下： 

1. 創建方式：Calendar.getInstance()
2. 日期時間：2008年07月22日 11:54:48
4. 創建方式：new GregorianCalendar()
5. 日期時間：2008年07月22日 11:54:48
7. 創建方式：new GregorianCalendar(2008, 8,
8. 日期時間：2008年09月08日 00:00:00
10. 創建方式：new GregorianCalendar(2008, 8, 8, 6, 10)
11. 日期時間：2008年09月08日 06:10:00
13. 創建方式：new GregorianCalendar(2008, 8, 8, 18, 10, 5)
14. 日期時間：2008年09月08日 18:10:05

爲了便於閱讀，我們增加一個toFriendlyString(Calendar c)方法，它將日期時間值格式化爲一種更加友好易懂的形式，我們將在接下來的內容中講解它的實現原理。分析運行結果後，我們發現有兩個地方需要注意： 

1. 在創建GregorianCalendar對象時，月份值都設定爲8，但打印結果都是9月份。這並不是我們的代碼有問題，而是因爲JAVA表示的月份是從0開始的，也就是說它用來表示月份的數值總是比實際月份值小1。因此我們要表示8月份，就是應該設置8-1=7這個值。
2. GregorianCalendar的小時數是24小時制的。

如果我們想要從Calendar對象獲得各種屬性的值，就需要調用它的get(int field)方法，這個方法接收一個int型的參數，並且根據這個給定參數的值來返回相應的屬性的值。該方法的定義如下： 

public int get(int field){
    //other code
}

我們以一個示例來說明get(int field)方法所能接受的一些常用參數的含義及用法： 

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

public class DateTest {
    /**
     * 以一種較爲友好的方式格式化日期時間值
     *
     * @param c
     *            日期時間對象
     * @return 格式化後的日期時間字符串
     */
    public static String toFriendlyString(Calendar c) {
        if (c != null) {
            DateFormat df = new SimpleDateFormat("yyyy年MM月dd日 HH:mm:ss.SSS");
            return df.format(c.getTime());
        }
        return null;
    }

    public static void main(String[] args) {
        Calendar c = Calendar.getInstance();
        System.out.println("當前時刻：" + DateTest.toFriendlyString(c));
        System.out.println();

        System.out.println("屬性名稱：Calendar.AM_PM");
        System.out.println("代表含義：上下午標識，上午返回Calendar.AM=0，下午返回Calendar.PM=1");
        System.out.println("測試結果：" + c.get(Calendar.AM_PM));
        System.out.println();

        System.out.println("屬性名稱：Calendar.DATE");
        System.out.println("代表含義：一個月中的第幾天，同Calendar.DAY_OF_MONTH");
        System.out.println("測試結果：" + c.get(Calendar.DATE));
        System.out.println();

        System.out.println("屬性名稱：Calendar.DAY_OF_MONTH");
        System.out.println("代表含義：一個月中的第幾天，同Calendar.DATE");
        System.out.println("測試結果：" + c.get(Calendar.DAY_OF_MONTH));
        System.out.println();

        System.out.println("屬性名稱：Calendar.DAY_OF_WEEK");
        System.out.println("代表含義：星期幾。");
        System.out.println("星期日:Calendar.SUNDAY=1");
        System.out.println("星期一:Calendar.MONDAY=2");
        System.out.println("星期二:Calendar.TUESDAY=3");
        System.out.println("星期三:Calendar.WEDNESDAY=4");
        System.out.println("星期四:Calendar.THURSDAY=5");
        System.out.println("星期五:Calendar.FRIDAY=6");
        System.out.println("星期六:Calendar.SATURDAY=7");
        System.out.println("測試結果：" + c.get(Calendar.DAY_OF_WEEK));
        System.out.println();

        System.out.println("屬性名稱：Calendar.DAY_OF_WEEK_IN_MONTH");
        System.out.println("代表含義：這一天所對應的星期幾在該月中是第幾次出現");
        System.out.println("測試結果：" + c.get(Calendar.DAY_OF_WEEK_IN_MONTH));
        System.out.println();

        System.out.println("屬性名稱：Calendar.DAY_OF_YEAR");
        System.out.println("代表含義：一年中的第幾天");
        System.out.println("測試結果：" + c.get(Calendar.DAY_OF_YEAR));
        System.out.println();

        System.out.println("屬性名稱：Calendar.HOUR");
        System.out.println("代表含義：12小時制下的小時數，中午和午夜表示爲0");
        System.out.println("測試結果：" + c.get(Calendar.HOUR));
        System.out.println();

        System.out.println("屬性名稱：Calendar.HOUR_OF_DAY");
        System.out.println("代表含義：24小時制下的小時數，午夜表示爲0");
        System.out.println("測試結果：" + c.get(Calendar.HOUR_OF_DAY));
        System.out.println();

        System.out.println("屬性名稱：Calendar.MILLISECOND");
        System.out.println("代表含義：毫秒數");
        System.out.println("測試結果：" + c.get(Calendar.MILLISECOND));
        System.out.println();

        System.out.println("屬性名稱：Calendar.MINUTE");
        System.out.println("代表含義：分鐘");
        System.out.println("測試結果：" + c.get(Calendar.MINUTE));
        System.out.println();

        System.out.println("屬性名稱：Calendar.MONTH");
        System.out.println("代表含義：月份，從0到11表示12個月份，比實際月份值小1");
        System.out.println("測試結果：" + c.get(Calendar.MONTH));
        System.out.println();

        System.out.println("屬性名稱：Calendar.SECOND");
        System.out.println("代表含義：秒");
        System.out.println("測試結果：" + c.get(Calendar.SECOND));
        System.out.println();

        System.out.println("屬性名稱：Calendar.WEEK_OF_MONTH");
        System.out.println("代表含義：一個月中的第幾個星期");
        System.out.println("測試結果：" + c.get(Calendar.WEEK_OF_MONTH));
        System.out.println();

        System.out.println("屬性名稱：Calendar.WEEK_OF_YEAR");
        System.out.println("代表含義：一年中的第幾個星期");
        System.out.println("測試結果：" + c.get(Calendar.WEEK_OF_YEAR));
        System.out.println();

        System.out.println("屬性名稱：Calendar.YEAR");
        System.out.println("代表含義：年份");
        System.out.println("測試結果：" + c.get(Calendar.YEAR));
    }
}

運行結果如下： 

1. 當前時刻：2008年07月22日 13:16:07.421
3. 屬性名稱：Calendar.AM_PM
4. 代表含義：上下午標識，上午返回Calendar.AM=0，下午返回Calendar.PM=1
5. 測試結果：1
7. 屬性名稱：Calendar.DATE
8. 代表含義：一個月中的第幾天，同Calendar.DAY_OF_MONTH
9. 測試結果：22
11. 屬性名稱：Calendar.DAY_OF_MONTH
12. 代表含義：一個月中的第幾天，同Calendar.DATE
13. 測試結果：22
15. 屬性名稱：Calendar.DAY_OF_WEEK
16. 代表含義：星期幾。
17. 星期日:Calendar.SUNDAY=1
18. 星期一:Calendar.MONDAY=2
19. 星期二:Calendar.TUESDAY=3
20. 星期三:Calendar.WEDNESDAY=4
21. 星期四:Calendar.THURSDAY=5
22. 星期五:Calendar.FRIDAY=6
23. 星期六:Calendar.SATURDAY=7
24. 測試結果：3
26. 屬性名稱：Calendar.DAY_OF_WEEK_IN_MONTH
27. 代表含義：這一天所對應的星期幾在該月中是第幾次出現
28. 測試結果：4
30. 屬性名稱：Calendar.DAY_OF_YEAR
31. 代表含義：一年中的第幾天
32. 測試結果：204
34. 屬性名稱：Calendar.HOUR
35. 代表含義：12小時制下的小時數，中午和午夜表示爲0
36. 測試結果：1
38. 屬性名稱：Calendar.HOUR_OF_DAY
39. 代表含義：24小時制下的小時數，午夜表示爲0
40. 測試結果：13
42. 屬性名稱：Calendar.MILLISECOND
43. 代表含義：毫秒數
44. 測試結果：421
46. 屬性名稱：Calendar.MINUTE
47. 代表含義：分鐘
48. 測試結果：16
50. 屬性名稱：Calendar.MONTH
51. 代表含義：月份，從0到11表示12個月份，比實際月份值小1
52. 測試結果：6
54. 屬性名稱：Calendar.SECOND
55. 代表含義：秒
56. 測試結果：7
58. 屬性名稱：Calendar.WEEK_OF_MONTH
59. 代表含義：一個月中的第幾個星期
60. 測試結果：4
62. 屬性名稱：Calendar.WEEK_OF_YEAR
63. 代表含義：一年中的第幾個星期
64. 測試結果：30
66. 屬性名稱：Calendar.YEAR
67. 代表含義：年份
68. 測試結果：2008

其中Calendar.DAY_OF_WEEK_IN_MONTH代表的含義比較難理解一些，它表示“這一天所對應的星期幾在該月中是第幾次出現”。比如2008年8月8日是星期五，在它之前的8月1日也是星期五，因此它是8月份的第二個星期五。所以這時調用get(Calendar.DAY_OF_WEEK_IN_MONTH)就會返回2。這裏存在一個簡單易記的規律：對於每月的1-7號，它們一定佔全了星期一到星期日，所以不管是它們中的哪一天，也不管這一天是星期幾，它總是第一個，因此返回1；8-14號也同樣佔全了星期一到星期日，但由於1-7號的關係，對於它們總是返回2；以此類推，15-21號返回3，22-28號返回4，29-31號返回5。 

Calendar對象和Date對象可以通過Calendar類的如下兩個方法進行相互轉換： 

public final Date getTime() {
    //other code
}

public final void setTime(Date date) {
    //other code
}

我們回頭再來看看在上面的例子中定義的toFriendlyString(Calendar c)方法，它將一個Calendar對象的日期時間值以一種很友好的方式來展現，使人們很容易看懂，也符合我們中國人的習慣。這完全得益於抽象類DateFormat以及它的子類實體類SimpleDateFormat的幫助。這兩個類都位於java.text包中，是專門用於日期格式化和解析的類。而這兩項工作的核心就是我們爲此設定的Pattern，我們可以稱之爲“日期格式表達式”。 

理論上講日期格式表達式包含全部26個英文字母的大小寫，不過它們中的一些字母只是被預留了，並沒有確切的含義。目前有效的字母及它們所代表的含義如下： 

• G：年代標識，表示是公元前還是公元后
• y：年份
• M：月份
• d：日
• h：小時，從1到12，分上下午
• H：小時，從0到23
• m：分鐘
• s：秒
• S：毫秒
• E：星期幾   
• z：時區
• D：一年中的第幾天
• F：這一天所對應的星期幾在該月中是第幾次出現
• w：一年中的第幾個星期
• W：一個月中的第幾個星期
• a：上午/下午標識
• k：小時，從1到24
• K：小時，從0到11，區分上下午

在日期格式表達式中出現的所有字母，在進行日期格式化操作後，都將被其所代表的含義對應的屬性值所替換，並且對某些字母來說，重複次數的不同，格式化後的結果也會有所不同。請看下面的例子： 

import java.text.SimpleDateFormat;
import java.util.Date;

public class DateTest {
    public static void main(String[] args) {
        // 使用系統當前日期時間值創建一個Date對象
        Date now = new Date();

        // 創建一個日期格式表達式
        String pattern = "年代:G;年份:y;月份:M;日:d;時(1~12):h;時(0~23):H;分:m;秒:s;毫秒:S;星期:E;上/下午:a;時區:z";
        // 使用日期格式表達式創建一個SimpleDateFormat對象
        SimpleDateFormat df = new SimpleDateFormat(pattern);
        // 調用SimpleDateFormat類的format(Date date)方法對Date對象進行格式化，並返回格式化後的字符串。
        // 該方法繼承自java.text.DateFormat類
        System.out.println("1位：" + df.format(now));

        // 創建一個新的日期格式表達式
        pattern = "年代:GG;年份:yy;月份:MM;日:dd;時(1~12):hh;時(0~23):HH;分:mm;秒:ss;毫秒:SS;星期:EE;上/下午:aa;時區:zz";
        // 調用SimpleDateFormat的applyPattern(String pattern)方法用新創建的日期格式表達式替換其原有的
        df.applyPattern(pattern);
        System.out.println("2位：" + df.format(now));

        pattern = "年代:GGG;年份:yyy;月份:MMM;日:ddd;時(1~12):hhh;時(0~23):HHH;分:mmm;秒:sss;毫秒:SSS;星期:EEE;上/下午:aaa;時區:zzz";
        df.applyPattern(pattern);
        System.out.println("3位：" + df.format(now));

        pattern = "年代:GGGG;年份:yyyy;月份:MMMM;日:dddd;時(1~12):hhhh;時(0~23):HHHH;分:mmmm;秒:ssss;毫秒:SSSS;星期:EEEE;上/下午:aaaa;時區:zzzz";
        df.applyPattern(pattern);
        System.out.println("4位：" + df.format(now));

        pattern = "年代:GGGGG;年份:yyyyy;月份:MMMMM;日:ddddd;時(1~12):hhhhh;時(0~23):HHHHH;分:mmmmm;秒:sssss;毫秒:SSSSS;星期:EEEEE;上/下午:aaaaa;時區:zzzzz";
        df.applyPattern(pattern);
        System.out.println("5位：" + df.format(now));

        pattern = "年代:GGGGGG;年份:yyyyyy;月份:MMMMMM;日:dddddd;時(1~12):hhhhhh;時(0~23):HHHHHH;分:mmmmmm;秒:ssssss;毫秒:SSSSSS;星期:EEEEEE;上/下午:aaaaaa;時區:zzzzzz";
        df.applyPattern(pattern);
        System.out.println("6位：" + df.format(now));
    }
}

輸出結果如下： 

1. 1位：年代:公元;年份:08;月份:7;日:22;時(1~12):3;時(0~23):15;分:17;秒:49;毫秒:187;星期:星期二;上/下午:下午;時區:CST
2. 2位：年代:公元;年份:08;月份:07;日:22;時(1~12):03;時(0~23):15;分:17;秒:49;毫秒:187;星期:星期二;上/下午:下午;時區:CST
3. 3位：年代:公元;年份:08;月份:七月;日:022;時(1~12):003;時(0~23):015;分:017;秒:049;毫秒:187;星期:星期二;上/下午:下午;時區:CST
4. 4位：年代:公元;年份:2008;月份:七月;日:0022;時(1~12):0003;時(0~23):0015;分:0017;秒:0049;毫秒:0187;星期:星期二;上/下午:下午;時區:中國標準時間
5. 5位：年代:公元;年份:02008;月份:七月;日:00022;時(1~12):00003;時(0~23):00015;分:00017;秒:00049;毫秒:00187;星期:星期二;上/下午:下午;時區:中國標準時間
6. 6位：年代:公元;年份:002008;月份:七月;日:000022;時(1~12):000003;時(0~23):000015;分:000017;秒:000049;毫秒:000187;星期:星期二;上/下午:下午;時區:中國標準時間

如果我們想輸出原始的字母，而不是它們所代表含義的替換值，就需要用單引號將它們包含在內，對於預留字母也是如此，雖然它們沒有確切的含義。一對單引號可以一次包含多個字母，而兩個連續的單引號將輸出一個單引號結果，雙引號則需要轉義後輸出。對於26個字母之外的字符，可以放在一對單引號中，也可以直接書寫。請看下面的例子： 

import java.text.SimpleDateFormat;
import java.util.Date;

public class Test {
    public static void main(String[] args) {
        Date now = new Date();
        SimpleDateFormat df = new SimpleDateFormat(
                "'YEAR': yyyy 'MONTH:' ''MM'' 'DAY:' \"dd\" ");
        System.out.println(df.format(now));
    }
}

運行結果： 

• YEAR: 2008 MONTH: '07' DAY: "22"

上面的一些例子中，我們將日期對象轉換成一定格式的字符串輸出，以得到符合我們習慣的較爲友好的表現形式。我們還可以反過來，使用DateFormat類的parse(String source)方法將具有一定格式的字符串轉換爲一個Date對象，前提是我們利用前面講到日期格式表達式語法爲其找到一個合適的Pattern。例如： 

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class DateTest {
    public static void main(String[] args) throws ParseException {
        String s = "2008-08-08";
        System.out.println("原始字符串：" + s);
        String pattern = "yyyy-MM-dd";
        System.out.println("對應表達式：" + pattern);
        SimpleDateFormat df = new SimpleDateFormat(pattern);
        Date date = df.parse(s);
        System.out.println("轉換後的值：" + date);
        System.out.println();

        s = "05年2月12日 18:04:33";
        System.out.println("原始字符串：" + s);
        pattern = "yy年M月d日 HH:mm:ss";
        System.out.println("對應表達式：" + pattern);
        df.applyPattern(pattern);
        date = df.parse(s);
        System.out.println("轉換後的值：" + date);
        System.out.println();

        s = "16/5/2004 20:7:2.050";
        System.out.println("原始字符串：" + s);
        pattern = "d/M/yyyy HH:m:s.SSS";
        System.out.println("對應表達式：" + pattern);
        df.applyPattern(pattern);
        date = df.parse(s);
        System.out.println("轉換後的值：" + date);
    }
}

運行結果： 

1. 原始字符串：2008-08-08
2. 對應表達式：yyyy-MM-dd
3. 轉換後的值：Fri Aug 08 00:00:00 CST 2008
5. 原始字符串：05年2月12日 18:04:33
6. 對應表達式：yy年M月d日 HH:mm:ss
7. 轉換後的值：Sat Feb 12 18:04:33 CST 2005
9. 原始字符串：16/5/2004 20:7:2.050
10. 對應表達式：d/M/yyyy HH:m:s.SSS
11. 轉換後的值：Sun May 16 20:07:02 CST 2004