天天看點
傳回

java8實戰十一: java8----新的日期時間API

java8中 新的時間和日期API

Java的API提供了很多有用的元件，能幫助你建構複雜的應用。不過，Java API也不總是完美

的。我們相信大多數有經驗的程式員都會贊同Java 8之前的庫對日期和時間的支援就非常不理想。

然而，你也不用太擔心：Java 8中引入全新的日期和時間API就是要解決這一問題。

為了解決

這些問題，Oracle決定在原生的Java API中提供高品質的日期和時間支援。是以，你會看到Java 8

在 java.time 包中整合了很多Joda-Time的特性。

接下來,我們會一起探索新的日期和時間API所提供的新特性。我們從最基本的用例入手，

比如建立同時适合人與機器的日期和時間，逐漸轉入到日期和時間API更進階的一些應用，比如

操縱、解析、列印輸出日期時間對象，使用不同的時區和年曆。

LocalDate,LocalTime.Instant,Duration,以及Period

讓我們從探索如何建立簡單的日期和時間間隔入手。 java.time 包中提供了很多新的類可以

幫你解決問題，它們是 LocalDate 、 LocalTime 、 Instant 、 Duration 和 Period 。

使用LocalDate和LocalTime

  • LocalDate

開始使用新的日期和時間API時，你最先碰到的可能是 LocalDate 類。該類的執行個體是一個不

可變對象，它隻提供了簡單的日期，并不含當天的時間資訊。另外，它也不附帶任何與時區相關

的資訊

該類不存儲或表示時間或時區。 相反，它是日期的描述，用于生日。 它不能代表時間線上的即時資訊，而沒有附加資訊，如偏移或時區。

這個類是不可變的和線程安全的。

你可以通過靜态工廠方法of建立一個 LocalDate 執行個體,LocalDate執行個體提供了很多的方法來讀取常用的 值,比如年份,月份,星期幾,是否閏年等等.

下面通過一個例子來簡單看一下:

@Test
    public void test(){

        LocalDate date = LocalDate.of(2017, 11, 23);

        System.out.println("年份:"+date.getYear());

        Month month = date.getMonth();
        System.out.println("月份(單詞):"+month);
        int monthValue = date.getMonthValue();
        System.out.println("月份(數字)"+monthValue);

        System.out.println("多少号:"+date.getDayOfMonth());


        System.out.println("傳回由此日期表示的月份的長度:"+date.lengthOfMonth());
        System.out.println("傳回由此日期表示的年份的長度:"+date.lengthOfYear());

        DayOfWeek dayOfWeek = date.getDayOfWeek();
        System.out.println("星期幾(單詞):"+dayOfWeek);
        System.out.println("星期幾(數字):"+dayOfWeek.getValue());


        System.out.println("一年中的第幾天:"+date.getDayOfYear());


        System.out.println("是否是閏年:"+ date.isLeapYear());

        LocalDate a = LocalDate.of(2012, 6, 30);
        System.out.println("檢查此日期是否在指定日期之後:"+ date.isAfter(a));
        System.out.println("檢查此日期是否在指定日期之前:"+date.isBefore(a));
        System.out.println("檢查此日期是否等于指定的日期。"+date.isEqual(a));

        System.out.println("将日期輸出:"+date.toString());


    }

輸出:

年份:2017
月份(單詞):NOVEMBER
月份(數字)11
多少号:23
傳回由此日期表示的月份的長度:30
傳回由此日期表示的年份的長度:365
星期幾(單詞):THURSDAY
星期幾(數字):4
一年中的第幾天:327
是否是閏年:false
檢查此日期是否在指定日期之後:true
檢查此日期是否在指定日期之前:false
檢查此日期是否等于指定的日期。false
将日期輸出:2017-11-23

你還可以使用工廠方法 now 從系統時鐘中擷取目前的日期

LocalDate today = LocalDate.now();
  • LocalTime

LocalTime是一個不可變的日期時間對象，代表一個時間，通常被看作是小時 - 秒。 時間表示為納秒精度。 例如，值“13：45.30.123456789”可以存儲在LocalTime 。

它不存儲或表示日期或時區。 相反，它是在挂鐘上看到的當地時間的描述。 它不能代表時間線上的即時資訊，而沒有附加資訊，如偏移或時區

這個類是不可變的和線程安全的。

類似地，一天中的時間，比如13:45:20，可以使用 LocalTime 類表示。你可以使用 of 重載的

兩個工廠方法建立 LocalTime 的執行個體。第一個重載函數接收小時和分鐘，第二個重載函數同時還

接收秒。同 LocalDate 一樣， LocalTime 類也提供了一些 getter 方法通路這些變量的值，如下

所示。

@Test
    public void test3(){
        LocalTime now = LocalTime.now();

        LocalTime time = LocalTime.of(15, 41, 30);
        LocalTime time2 = LocalTime.of(15, 41);

        int hour = time.getHour();
        int minute = time.getMinute();
        int second = time.getSecond();
        System.out.println("小時:"+hour+"分鐘:"+minute+"秒:"+second);

        System.out.println(now.toString());

    }

LocalDate和LocalTime都可以通過解析代表它們的字元串建立:如

@Test
    public void test4(){
       String date = "2017-11-23";
       String time = "15:51:30";
        LocalDate localDate = LocalDate.parse(date);
        LocalTime localTime = LocalTime.parse(time);
        System.out.println(localDate);
        System.out.println(localTime);

    }

prase還有一個重載方法: ​

​public static LocalDate parse(CharSequence text, DateTimeFormatter formatter)​

​

可以傳遞一個 DateTimeFormatter ,該類的執行個體訂立了如歌格式化一個時間或日期對象.它是替換老版 java.util.DateFormat 的推薦替代品。

後面我們介紹它.同時，也請注意，一旦傳遞的字元串參數無法被解析為合法的 LocalDate 或 LocalTime 對象，這兩個 parse 方法都會抛出一個繼

承自 RuntimeException 的 DateTimeParseException 異常

合并日期和時間 LocalDateTime

LocalDateTime是一個不可變的日期時間對象，代表日期時間，通常被視為年 - 月 - 日 - 時 - 分 - 秒。 也可以通路其他日期和時間字段，例如日期，星期幾和星期。 時間表示為納秒精度。

該類不存儲或表示時區。 相反，它是對日子的描述，如用于生日，結合當地時間在挂鐘上看到的。 它不能代表時間線上的即時資訊，而沒有附加資訊，如偏移或時區。

這個類是不可變的和線程安全的。

LocalDateTime ，是 LocalDate 和 LocalTime 的合體。它同時表示了日期

和時間，但不帶有時區資訊，你可以直接建立，也可以通過合并日期和時間對象構造，如下所示:

介紹了LocalDateTime ,LocalDate ,LocalTime ,讓我們看看它們之間的互相轉換

/**
      * LocalDateTime ,LocalDate ,LocalTime 互相轉換
      */
     @Test
     public void test5(){
         String date = "2017-11-23";
         String time = "15:51:30";
         LocalDate localDate = LocalDate.parse(date);
         LocalTime localTime = LocalTime.parse(time);

         LocalDateTime localDateTime = LocalDateTime.of(2017, 11, 23, 16, 01, 30, 888);
         LocalDateTime localDateTime1 = LocalDateTime.of(localDate, localTime);

         //localDateTime-->LocalDate,LocalTime
         LocalDate localDate1 = localDateTime.toLocalDate();
         LocalTime localTime1 = localDateTime.toLocalTime();

         // LocalDate,LocalTime --> LocalDateTime
         LocalDateTime localDateTime2 = localDate.atTime(16, 02, 30);
         LocalDateTime localDateTime3 = localTime.atDate(localDate);

     }

機器的日期和時間格式 Instant

  • Instant

作為人，我們習慣于以星期幾、幾号、幾點、幾分這樣的方式了解日期和時間。毫無疑問，

這種方式對于計算機而言并不容易了解。從計算機的角度來看，模組化時間最自然的格式是表示一

個持續時間段上某個點的單一大整型數。

這也是新的 java.time.Instant 類對時間模組化的方

式，基本上它是以Unix元年時間（傳統的設定為UTC時區1970年1月1日午夜時分）開始所經曆的

秒數進行計算。

該類在時間線上建立單個瞬時點。 這可能用于在應用程式中記錄事件時間戳。

實際上，這一瞬間存在一些限制。 可測量的時間線限制在long中可以持有的long 。 這大于目前估計的宇宙年齡。 該瞬間存儲為納秒分辨率。

這個類是不可變的和線程安全的。

你可以通過向靜态工廠方法 ofEpochSecond 傳遞一個代表秒數的值建立一個該類的執行個體。靜

态工廠方法 ofEpochSecond 還有一個增強的重載版本，它接收第二個以納秒為機關的參數值，對

傳入作為秒數的參數進行調整。重載的版本會調整納秒參數，確定儲存的納秒分片在0到999 999

999之間。這意味着下面這些對 ofEpochSecond 工廠方法的調用會傳回幾乎同樣的 Instant 對象：

/**
     * Instant
     */
    @Test
    public void test6(){
        Instant instant = Instant.ofEpochSecond(3);
        //2秒加上100萬納秒(1秒)
        Instant instant1 = Instant.ofEpochSecond(2, 1_000_000_000);

        //4秒減去100萬納秒(1秒)
        Instant instant2 = Instant.ofEpochSecond(4, -1_000_000_000);

        System.out.println(instant);//1970-01-01T00:00:03Z
        System.out.println(instant1);//1970-01-01T00:00:03Z
        System.out.println(instant2);//1970-01-01T00:00:03Z

正如你已經在 LocalDate 及其他為便于閱讀而設計的日期時間類中所看到的那樣，

Instant 類也支援靜态工廠方法 now ，它能夠幫你擷取目前時刻的時間戳。我們想要特别強調一

點， Instant 的設計初衷是為了便于機器使用。它包含的是由秒及納秒所構成的數字。是以，它

無法處理那些我們非常容易了解的時間機關。比如下面這段語句：

int

它會抛出下面這樣的異常：

java.time.temporal.UnsupportedTemporalTypeException: Unsupported field:
    DayOfMonth

但是你可以通過 Duration 和 Period 類使用 Instant ，接下來我們會對這部分内容進行介紹。

定義 Duration 或 Period

目前為止，你看到的所有類都實作了 Temporal 接口， Temporal 接口定義了如何讀取和操縱

為時間模組化的對象的值。之前的介紹中，我們已經了解了建立 Temporal 執行個體的幾種方法。很自

然地你會想到，我們需要建立兩個 Temporal 對象之間的 duration 。 Duration 類的靜态工廠方

法 between 就是為這個目的而設計的。你可以建立兩個 LocalTimes 對象、兩個 LocalDateTimes對象，或者兩個 Instant 對象之間的 duration ，如下所示：

Duration d1 = Duration.between(time1, time2);
Duration d1 = Duration.between(dateTime1, dateTime2);
Duration d2 = Duration.between(instant1, instant2);

由于 LocalDateTime 和 Instant 是為不同的目的而設計的，一個是為了便于人閱讀使用，

另一個是為了便于機器處理，是以你不能将二者混用。如果你試圖在這兩類對象之間建立

duration ，會觸發一個 DateTimeException 異常。此外，由于 Duration 類主要用于以秒和納

秒衡量時間的長短，你不能僅向 between 方法傳遞一個 LocalDate 對象做參數。

如果你需要以年、月或者日的方式對多個時間機關模組化，可以使用 Period 類。使用該類的

工廠方法 between ，你可以使用得到兩個 LocalDate 之間的時長，如下所示：

Period tenDays = Period.between(LocalDate.of(2014, 3, 8),
LocalDate.of(2014, 3, 18));

截至目前，我們介紹的這些日期時間對象都是不可修改的，這是為了更好地支援函數式編

程，確定線程安全，保持領域模式一緻性而做出的重大設計決定。當然，新的日期和時間API也

提供了一些便利的方法來建立這些對象的可變版本。比如，你可能希望在已有的 LocalDate 執行個體

上增加3天。我們在下一節中會針對這一主題進行介紹。除此之外，我們還會介紹如何依據指定

的模式，比如 dd/MM/yyyy ，建立日期時間格式器，以及如何使用這種格式器解析和輸出日期。

操縱、解析和格式化日期

如果你已經有一個 LocalDate 對象，想要建立它的一個修改版，最直接也最簡單的方法是使

用 withAttribute 方法。 withAttribute 方法會建立對象的一個副本，并按照需要修改它的屬

性。注意，下面的這段代碼中所有的方法都傳回一個修改了屬性的對象。它們都不會修改原來的

對象！

@Test
    public void test7(){
        LocalDate date = LocalDate.of(2014, 12, 18);
        LocalDate date2 = date.withYear(2017);
        System.out.println(date2);//2017-12-18
        LocalDate date3 = date2.withDayOfMonth(25);
        System.out.println(date3);//2017-12-25
        LocalDate date4 = date3.with(ChronoField.MONTH_OF_YEAR, 9);
        System.out.println(date4);//2017-09-25

​

​LocalDate date4 = date3.with(ChronoField.MONTH_OF_YEAR, 9);​

​

采用更通用的 with 方法能達到同樣的目的，它接受的第一個參數是一個 TemporalField 對

象,比如最後這一行中使用的 with 方法.

所有的日期和時間API類都實作這個方法,比如 LocalDate 、 LocalTime 、 LocalDateTime 以及 Instant .

更确切

地說，使用 get 和 with 方法，我們可以将 Temporal 對象值的讀取和修改區分開。如果 Temporal

對象不支援請求通路的字段，它會抛出一個 UnsupportedTemporalTypeException 異常，比

如試圖通路 Instant 對象的 ChronoField.MONTH_OF_YEAR 字段，或者 LocalDate 對象的

ChronoField.NANO_OF_SECOND 字段時都會抛出這樣的異常。

它甚至能以聲明的方式操縱 LocalDate 對象。比如，你可以像下面這段代碼那樣加上或者減

去一段時間

@Test
    public void test8(){
        LocalDate date1 = LocalDate.of(2014, 3, 18);
        LocalDate date2 = date1.plusWeeks(1);
        System.out.println(date2);//2014-03-25
        LocalDate date3 = date2.plusYears(3);
        System.out.println(date3);//2017-03-25

        LocalDate date4 = date3.plus(6, ChronoUnit.MONTHS);
        System.out.println(date4);//2017-09-25

​

​LocalDate date4 = date3.plus(6, ChronoUnit.MONTHS);​

​​

與我們剛才介紹的 get 和 with 方法類似，代碼中最後一行使用的 plus 方法也是通用

方法，它和 minus 方法都聲明于 Temporal 接口中。通過這些方法，對 TemporalUnit 對象加上

或者減去一個數字，我們能非常友善地将 Temporal 對象前溯或者復原至某個時間段，通過

ChronoUnit 枚舉我們可以非常友善地實作 TemporalUnit 接口.

大概你已經猜到，像 LocalDate 、 LocalTime 、 LocalDateTime 以及 Instant 這樣表示時

間點的日期時間類提供了大量通用的方法，下表對這些通用的方法進行了總結

使用 TemporalAdjuster 調整時間對象的政策

截至目前，你所看到的所有日期操作都是相對比較直接的。有的時候，你需要進行一些更加

複雜的操作，比如，将日期調整到下個周日、下個工作日，或者是本月的最後一天。

這時，你可

以使用重載版本的 with 方法，向其傳遞一個提供了更多定制化選擇的 TemporalAdjuster 對象，

更加靈活地處理日期。對于最常見的用例，日期和時間API已經提供了大量預定義的

TemporalAdjuster 。你可以通過 TemporalAdjuster 類的靜态工廠方法通路它們，如下所示:

@Test
    public void test9(){
        LocalDate date = LocalDate.of(2017, 11, 23);
        //調整日期到本周日
        LocalDate localDate = date.with(TemporalAdjusters.nextOrSame(DayOfWeek.SUNDAY));
        System.out.println(localDate);//2017-11-26
        //調整日期到本月最後一天
        LocalDate localDate1 = localDate.with(TemporalAdjusters.lastDayOfMonth());
        System.out.println(localDate1);//2017-11-30

表12-3提供了 TemporalAdjuster 中包含的工廠方法清單。

正如我們看到的，使用 TemporalAdjuster 我們可以進行更加複雜的日期操作，而且這些方

法的名稱也非常直覺，方法名基本就是問題陳述。此外，即使你沒有找到符合你要求的預定義的

TemporalAdjuster ，建立你自己的 TemporalAdjuster 也并非難事。實際上， Temporal-

Adjuster 接口隻聲明了單一的一個方法（這使得它成為了一個函數式接口），定義如下。

@FunctionalInterface
public interface TemporalAdjuster

這是一個功能界面，是以可以用作lambda表達式或方法引用的指派對象。

舉例:

請設計一個 NextWorkingDay 類，該類實作了 TemporalAdjuster 接口，能夠計算明天

的日期，同時過濾掉周六和周日這些節假日。

如果你想要使用Lambda表達式定義 TemporalAdjuster 對象，推薦使用 Temporal-

Adjusters 類的靜态工廠方法 ofDateAdjuster ，它接受一個 UnaryOperator

類型的參數，代碼如下：

@Test
    public void test10() {
        LocalDate date = LocalDate.of(2017, 11, 23);
        TemporalAdjuster nextWorkingDay = TemporalAdjusters.ofDateAdjuster(
                temporal -> {
                    //讀取目前天數
                    DayOfWeek dow = DayOfWeek.of(temporal.get(ChronoField.DAY_OF_WEEK));
                    //正常情況增加1天
                    int dayToAdd = 1;
                    //如果當天是周五,增加三天
                    if (dow == DayOfWeek.FRIDAY) {
                        dayToAdd = 3;
                    }
                    //如果當天是周六增加兩天
                    if (dow == DayOfWeek.SATURDAY) {
                        dayToAdd = 2;
                    }
                    //增加恰當的天數後,傳回修改的日期
                    return

列印輸出及解析日期 時間對象

處理日期和時間對象時，格式化以及解析日期時間對象是另一個非常重要的功能。新的

java.time.format 包就是特别為這個目的而設計的。這個包中，最重要的類是 DateTime-

Formatter 。

建立格式器最簡單的方法是通過它的靜态工廠方法以及常量。像 BASIC_ISO_DATE

和 ISO_LOCAL_DATE 這 樣 的 常 量 是 DateTimeFormatter 類 的 預 定 義 實 例 。 所 有 的

DateTimeFormatter 執行個體都能用于以一定的格式建立代表特定日期或時間的字元串。比如，下

面的這個例子中，我們使用了兩個不同的格式器生成了字元串：

@Test
    public void test11() {
        LocalDate date = LocalDate.of(2017, 11, 23);
        System.out.println(date);

        String format = date.format(DateTimeFormatter.BASIC_ISO_DATE);
        System.out.println(format);//20171123

        String format1 = date.format(DateTimeFormatter.ISO_LOCAL_DATE);
        System.out.println(format1);//2017-11-23

你也可以通過解析日期或時間字元串重新重新建立改日期對象.

@Test
    public void test12() {
        LocalDate localDate = LocalDate.parse("20171123", DateTimeFormatter.BASIC_ISO_DATE);
        System.out.println(localDate);//2017-11-23

        LocalDate localDate1 = LocalDate.parse("2017-11-23", DateTimeFormatter.ISO_LOCAL_DATE);
        System.out.println(localDate1);//2017-11-23      
/**
 * 把目前時間格式為指定格式
 */
@Test
public void test5(){
    //獲得目前時間
    LocalDateTime ldt = LocalDateTime.now();
    System.out.println(ldt);
    DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss");
    String format = ldt.format(dtf);
    System.out.println(format);
}

/**
 * 把指定字元串格式化為日期
 */
@Test
public void test6(){
    String str1="2018-07-05 12:24:12";
    DateTimeFormatter dtf = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
    LocalDateTime parse = LocalDateTime.parse(str1, dtf);
    System.out.println(parse);
}

和老的 java.util.DateFormat 相比較，所有的 DateTimeFormatter 執行個體都是線程安全

的。是以，你能夠以單例模式建立格式器執行個體，就像 DateTimeFormatter 所定義的那些常量，

并能在多個線程間共享這些執行個體。 DateTimeFormatter 類還支援一個靜态工廠方法，它可以按

照某個特定的模式建立格式器

@Test
    public void test13() {
        DateTimeFormatter pattern = DateTimeFormatter.ofPattern("dd/MM/yyyy");// dd天 ,MM月 ,yyyy年
        LocalDate date = LocalDate.of(2017, 11, 23);
        String format = date.format(pattern);
        System.out.println(format);//23/11/2017

小結

  • Java 8之前老版的 java.util.Date 類以及其他用于模組化日期時間的類有很多不一緻及

    設計上的缺陷，包括易變性以及糟糕的偏移值、預設值和命名

  • 新版的日期和時間API中，日期時間對象是不可變的。
  • 新的API提供了兩種不同的時間表示方式，有效地區分了運作時人和機器的不同需求

  • 你可以用絕對或者相對的方式操縱日期和時間，操作的結果總是傳回一個新的執行個體，老

    的日期時間對象不會發生變化。

  • TemporalAdjuster 讓你能夠用更精細的方式操縱日期，不再局限于一次隻能改變它的

    一個值，并且你還可按照需求定義自己的日期轉換器

  • 你現在可以按照特定的格式需求，定義自己的格式器，列印輸出或者解析日期時間對象。

    這些格式器可以通過模闆建立，也可以自己程式設計建立，并且它們都是線程安全的。

java 工廠方法 線程安全
上一篇: jetty啟動ssm-web項目welcome-file-list不生效
下一篇: 運維監控工具之 Nagios 用戶端安裝(二)

繼續閱讀