JDK8日期API

前言：
本篇文章搬運于 B站 -> 黑馬程式員 -> Java基礎教程2020新版JDK8日期API決議
感謝黑馬程式員的良心教育，祝黑馬程式員越來越好！

1、為什么會出現新的日期類 API ？

在 Java 面世之初，標準庫中就引入了兩種用于處理日期和時間的類，分別是 java.util.Date 和 java.util.Calendar，但是由于很多問題，很多方法都已經棄用，在 JavaSE 8 中引入 java.time 包解決了長久以來存在的諸多弊端，java.time 包基于 Joda-Time 庫構件，是一種免費的開源解決方法，多年來一直作為處理 Java 日期和時間的事實標準，Java 原本自帶的 java.util.Date 和 java.util.Calendar 類，實際上這兩種類有 執行緒不安全 的風險，

問題1：對于日期的計算困難問題

• 毫秒值與日期直接轉換比較繁瑣，其次通過毫秒值來計算時間的差額步驟較多，

問題2：執行緒不安全問題

• SimpleDateFormat 類是執行緒不安全的，在多執行緒的情況下，全域共享一個，
• SimpleDateFormat 類中的 Calendar 物件有可能會出現例外，

問題3：使用規范問題

• 另外的一個問題就是在 java.util.Date 和 java.util.Calendar 類之前，列舉型別（ENUM）還沒有出現，所以在欄位中使用整數常量導致整數常量都是可變的,而不是執行緒安全的，為了處理實際開發中遇到的問題，標準庫隨后引入了 java.sql.Date 作為 java.util.Date 的子類，但是還是沒能徹底解決問題，

2、Date-Time API 中的基本類使用

常用類的概述與功能介紹

Instant 類

• Instant 類對時間軸上的單一瞬時點建模，可以用于記錄應用程式中的事件時間戳，

Duration 類

• Duration 類表示秒或納秒時間間隔，適合處理較短的時間，需要更高的精確性，

Period 類

• Period 類表示一段時間的年、月、日，

LocalDate 類

• LocalDate 類是一個不可變的日期時間物件，表示日期，通常被視為年月日，

LocalTime 類

• LocalTime 類是一個不可變的日期時間物件，代表一個時間，通常被看作是時分秒，時間表示為納秒精度，

LocalDateTime 類

• LocalDateTime 類是一個不可變的日期時間物件，代表日期時間，通常被視為年月日時分秒，

ZonedDateTime 類

• ZonedDateTime 類是具有時區的日期時間的不可變表示，此類存盤所有日期和時間欄位，精度為納秒，時區為區域偏移量，用于處理模糊的本地日期時間，

now 方法在日期/時間類的使用

Date-Time API 中的所有類均生成不可變實體，它們是執行緒安全的，并且這些類不提供公共建構式，也就是說沒辦法通過 new 的方式直接創建，需要采用工廠方法加以實體化，

now 方法可以根據當前日期或時間創建實體，

public static void main(String[] args) {
	Instant instant = Instant.now();
	LocalDate localDate = LocalDate.now();
	LocalTime localTime = LocalTime.now();
	LocalDateTime localDateTime = LocalDateTime.now();
	ZonedDateTime zonedDateTime = ZonedDateTime.now();
}

不僅僅是剛才提供的幾個類可以使用 now 方法，Java8 的 Time 包中還提供了其他的幾個類可以更精準的獲取某些資訊，

• Year 類（表示年）
• YearMonth 類（表示年月）
• MonthDay 類（表示月日）

public static void main(String[] args) {
	Year year = Year.now();
	YearMonth yearMonth = YearMonth.now();
	MonthDay monthDay = MonthDay.now();
}

of 方法在日期/時間類的應用

of 方法可以根據給定的引數生成對應的日期/時間物件，基本上每個基本類都有 of 方法用于生成的對應的物件，而且多載形式多變，可以根據不同的引數生成對應的資料，

public static void main(String[] args) {
    // 初始化一個2018年8月8日的LocalDate物件
    LocalDate localDate = LocalDate.of(2018, 8, 8);
    System.out.println("localDate : " + localDate);

    // 初始化晚上8點0分0秒的LocalDate物件，如果是晚上的時間，需要加上12個小時
    LocalTime localTime = LocalTime.of(20, 0, 0, 0);
    System.out.println("localTime : " + localTime);

    // 初始化2018年8月8日下午8點0分的LocalDateTime物件
    LocalDateTime localDateTime = LocalDateTime.of(2018,8,8,20,0);
    System.out.println("localDateTime : " + localDateTime);

    // LocalDateTime的of方法的特殊使用
    LocalDateTime localDateTime1 = LocalDateTime.of(localDate, localTime);
    System.out.println("localDateTime1 : " + localDateTime1);
}

為 LocalDateTime 添加時區資訊（拓展）

ZonedDateTime 這個物件里面封裝的不僅有時間日期，并且還有偏移量 + 時區，那么時區如何在 Java 中獲取呢，通過提供的一個類 ZoneId 的 getAvailableZoneIds 方法可以獲取到一個 set 集合，集合中封裝了 608 個時區，同樣也提供了獲取當前系統默認的時區的方式 systemDefault() 方法，

public static void main(String[] args) {
    // 獲取所有的時區資訊
    Set<String> availableZoneIds = ZoneId.getAvailableZoneIds();
    for (String availableZoneId : availableZoneIds) {
        System.out.println(availableZoneId);
    }
    // 獲取當前系統默認的時區資訊
    ZoneId zoneId = ZoneId.systemDefault();
    System.out.println(zoneId);
}

我們可以通過給 LocalDateTime 添加時區資訊來查看到不同時區的時間，比如說 LocalDateTime 中當前封裝的是上海時間，那么想知道在此時此刻，紐約的時間是什么，就可以將紐約的時區 Id 添加進去，就可以查看到了，方式如下：

• 封裝時間 LocalDateTime 并添加時區資訊，
• 更改時區資訊查看對應時間，

public static void main(String[] args) {
    // 初始化LocalDateTime物件
    LocalDateTime localDateTime = LocalDateTime.now();
    // 添加時區資訊到物件中，使用atZone()方法
    ZonedDateTime zonedDateTime = localDateTime.atZone(ZoneId.of("Asia/Shanghai"));
    System.out.println("Asia/Shanghai -> 當前時間 : " + zonedDateTime);
    // 更改時區查看其他時區的當前時間，通過方法
    ZonedDateTime zonedDateTime1 = zonedDateTime.withZoneSameInstant(ZoneId.of("Asia/Tokyo"));
    System.out.println("Asia/Tokyo -> 當前時間 : " + zonedDateTime1);
}

Month 列舉類的使用

java.time 包中引入了 Month 的列舉，Month 中包含標準日歷中的 12 個月份的常量（從 JANURAY 到 DECEMEBER）也提供了一些方便的方法供我們使用，

推薦在初始化 LocalDate 和 LocalDateTime 物件的時候，月份的引數使用列舉的方式傳入，這樣更簡單易懂而且不易出錯，因為如果是老的思維，Calendar 傳入 0 的話，那么會出現例外，

public static void main(String[] args) {
    // 初始化LocalDateTime物件，月份使用列舉
    LocalDateTime localDateTime = LocalDateTime.of(2018,Month.JUNE,15,11,11,11);
    System.out.println("localDateTime : " + localDateTime);

    // of方法可以根據傳入的數字回傳對應的月份
    Month month = Month.of(12);
    System.out.println("month : " + month);
}

3、根據現有實體創建曰期與時間物件

想要修改某個日期/時間物件的現有實體時，我們可以使用 plus 和 minus 方法來完成操作，Java8 中日期時間相關的 API 中的所有實體都是不可改變的，一旦創建 LocalDate，LocalTime，LocalDateTime 就無法修改他們（類似于 String），這對于執行緒安全非常有利，

plus 方法在 LocalDate 與 LocalTime 中的使用

LocalDate 中定義了多種對日期進行增減操作的方法：

• LocalDate plusDays(long days) ：增加天數，
• LocalDate plusWeeks(long weeks) ：增加周數，
• LocalDate plusMonths(long months) ：增加月數，
• LocalDate plusYears(long years) ：增加年數，
• …

public static void main(String[] args) {
   // 初始化LocalDate物件
    LocalDate localDate = LocalDate.now();
    System.out.println("當前日期 : " + localDate);
    // 計算當前日期4天后的日期
    LocalDate localDate1 = localDate.plusDays(4);
    System.out.println("當前日期4天后的日期 : " + localDate1);
    // 計算當前日期3周后的日期
    LocalDate localDate2 = localDate.plusWeeks(3);
    System.out.println("當前日期3周后的日期 : " + localDate2);
    // 計算當前日期5個月后的日期
    LocalDate localDate3 = localDate.plusMonths(5);
    System.out.println("當前日期5個月后的日期 : " + localDate3);
    // 計算當前日期2年后的日期
    LocalDate localDate4 = localDate.plusYears(2);
    System.out.println("當前日期2年后的日期 : " + localDate4);
}

LocalTime 中定義了多種對日期進行增減操作的方法：

• LocalTime plusNanos(long nanos) ：增加納秒，
• LocalTime plusSeconds(long seconds) ：增加秒，
• LocalTime plusMinutes(long minutes) ：增加分鐘，
• LocalTime plusHougs(long hours) ：增加小時，
• …

上面的示例都是使用 plusXx 方法進行演示的，實際上也有對應的減少方法，以 minus 開頭的方法對應的即為減少，實際上 minus 方法呼叫的也是 plus 方法，只不過傳入的引數是負數，

plus 和 minus 方法的應用

剛才學習到的 plusXx 相關的方法都是添加了數值到具體的某一項上，根據觀察還有兩個單獨的plus方法，接下來我們來學習這兩個單獨的plus方法，

• plus(TemporaAmount amountToAdd) ：TemporaAmount 是一個介面，當介面作為方法的引數的時候，實際上傳入的是介面的實作類物件，它的實作類有 Duration 和 Period 等，

public static void main(String[] args) {
    // 今天程式員小張查看自己的車輛保險記錄的時候看到還有2年3月8天就到期了，計算到期的日期是什么時候？
    // 方法1
    LocalDate dueDate = LocalDate.now().plusYears(2).plusMonths(3).plusDays(8);
    System.out.println("到期日期 : " + dueDate);

    // 方法2
    Period period = Period.of(2,3,8);
    LocalDate dueDate1 = LocalDate.now().plus(period);
    System.out.println("到期日期 : " + dueDate1);
}

• plus(long 1,TemporaUnit unit) ：在實際開發程序中，可能還會更精準的去操作日期或者說增加一些特殊的時間，比如說1個世紀，1個半天，1千年，10年等，Java8 提供了這些日期的表示方式而不需要去單獨進行計算了，TemporaUnit 是一個介面，通過查看體系介面發現，可以使用子類 ChronoUnit 來表示，ChronoUnit 封裝了很多時間段供我們使用，

public static void main(String[] args) {
    // 結婚10年稱為錫婚，2020年2月2日11點11分11秒稱為對稱日，很多情侶準備在那天結婚，如果在那天結婚了，那么錫婚會發生在什么時候？
    LocalDateTime marryTime = LocalDateTime.of(2020,Month.FEBRUARY,2,11,11,11);
    LocalDateTime dateTime = marryTime.plus(1, ChronoUnit.DECADES);
    System.out.println("錫婚發生時間 : " + dateTime);
}

with 方法在 LocalDateTime 類的應用

如果不需要對日期進行加減而是要直接修改日期的話，那么可以使用 with 方法，with 方法提供了很多種修改時間的方式，

• Loca1DateTime withNano(int i) ：修改納秒，
• LocalDateTime withSecond(int i) ：修改秒，
• LocalDateTime withMinute(int i) ：修改分鐘，
• LocalDateTime withHour(int i) ：修改小時，
• LocalDateTime withDayOfMonth(int i) ：修改日，
• LocalDateTime withMonth(int i) ：修改月，
• LocalDateTime withYear(int i) ：修改年，

public static void main(String[] args) {
   LocalDateTime localDateTime = LocalDateTime.of(2020,Month.FEBRUARY,18,11,11,11);
    System.out.println("修改前：" + localDateTime);
    LocalDateTime localDateTime1 = localDateTime.withDayOfMonth(8);
    System.out.println("修改后：" + localDateTime1);
}

• with(TemporalField field,long newValue) ：TemporalField 是一個介面，通過查看體系結構，可以使用它的子類 ChronoField，ChronoField中 封裝了一些日期時間中的組成部分，可以直接選擇之后傳入第二個引數進行修改，
  例：with(ChronoField.DAY_OF_MONTH,1) 就是將日期中的月份中的天數改為1，
  例：with(ChronoField. YEAR,2021) 就是將日期中的年份改為2021，

public static void main(String[] args) {
    LocalDateTime localDateTime = LocalDateTime.of(2020,Month.FEBRUARY,18,11,11,11);
    System.out.println("修改前：" + localDateTime);
    LocalDateTime localDateTime1 = localDateTime.with(ChronoField.DAY_OF_MONTH,8);
    System.out.println("修改后：" + localDateTime1);
}

4、調節器 TemporalAdjuster 與查詢 TemporalQuery

在上一節學習的 with 方法中學習了可以通過 with 方法修改日期時間物件中封裝的資料，但是有一些時候可能會做一些復雜的操作，比如說將時間調整到下個周的周日，下一個作業日，或者本月中的某一天，這個時候可以使用調節器 TemporalAdjuster 來更方便的處理日期，

Java 8 提供了一個叫做 TemporalAdjusters 的類可以給我們提供一些常用的方法，方法如下：

• static TemporalAdjuster firstDayOfMonth() ：本月的第一天，
• static TemporalAdjuster firstDayOfNextMonth() ：下個月的第一天，
• static TemporalAdjuster firstDayOfYear() ：本年的第一天，
• static TemporalAdjuster firstDayOfNextYear() ：下一年的第一天，
• static TemporaAdjuste lastInMonth(DayOfweek dayOfweek) ：當月的最后一個周x（通過引數確定），
• static TemporaAdjuster next(DayOfWeek dayOfweek) ：下一個周x（通過引數確定），
• static TemporaAdjuster previous(DayOfweek dayOfweek) ：上一個周x（通過引數確定），
• …

public static void main(String[] args) {
    LocalDate localDate = LocalDate.now();
    // 修改日期為本月的第一天
    LocalDate localDate1 = localDate.with(TemporalAdjusters.firstDayOfMonth());
    System.out.println("本月的第一天的日期：" + localDate1);
    // 修改日期為本月的最后一天
    LocalDate localDate2 = localDate.with(TemporalAdjusters.lastDayOfMonth());
    System.out.println("本月的最后一天的日期：" + localDate2);
    // 修改日期為下個月的第一天
    LocalDate localDate3 = localDate.with(TemporalAdjusters.firstDayOfNextMonth());
    System.out.println("下個月的第一天的日期：" + localDate3);
    // 修改日期為下一年的第一天
    LocalDate localDate4 = localDate.with(TemporalAdjusters.firstDayOfNextYear());
    System.out.println("下一年的第一天的日期：" + localDate4);
}

DayOfWeek 的使用

DayOfWeek 是一周中星期幾的列舉類其中封裝了從周一到周日，

public static void main(String[] args) {
    LocalDate localDate = LocalDate.now();
    // 修改日期為下一個周日
    LocalDate localDate1 = localDate.with(TemporalAdjusters.next(DayOfWeek.SUNDAY));
    System.out.println("下一個周日的日期：" + localDate1);
    // 修改日期為上一個周三
    LocalDate localDate2 = localDate.with(TemporalAdjusters.previous(DayOfWeek.WEDNESDAY));
    System.out.println("上一個周三的日期：" + localDate2);
}

自定義 TemporalAdjuster 調節器

通過 Java 8 本身提供的 TemporalAdjusters 中的方法可以完成一些常用的操作，如果要自定義日期時間的更改邏輯，可以通過實作 TemporalAdjuster 類介面中的方式來完成，

1. 創建類實作 TemporalAdjuster 介面，
2. 實作 TemporalAdjuster 中的 adjustInto 方法，傳入一個日期時間物件，完成邏輯之后回傳日期時間物件，
3. 通過 with 方法傳入自定義調節器物件完成更改，

例：假如員工一個月中領取工資，發薪日是每個月的15號，如果發薪日是周末，則調整為周五，

package com.y2.test1.time;

import java.time.DayOfWeek;
import java.time.LocalDate;
import java.time.temporal.Temporal;
import java.time.temporal.TemporalAdjuster;
import java.time.temporal.TemporalAdjusters;

public class PayDayAdjuster implements TemporalAdjuster {
    @Override
    public Temporal adjustInto(Temporal temporal) {
        // 1.Temporal是日期時間類物件的父介面，實際上可以理解為傳入的就是LocalDate或者是LocalTime等物件，需要將temporal轉換為LocalDate物件
        LocalDate payDate = LocalDate.from(temporal);
        // 2.判斷傳入的日期是否為本月15日，如果不是，則修改為15日
        int day;
        if (payDate.getDayOfMonth() != 15) {
            day = 15;
        }else {
            day = payDate.getDayOfMonth();
        }
        // 3.判斷傳入日期是否為周末，如果為周末，則將日期修改為上一個周五
        LocalDate realPayDate = payDate.withDayOfMonth(day);
        if (realPayDate.getDayOfWeek() == DayOfWeek.SATURDAY || realPayDate.getDayOfWeek() == DayOfWeek.SUNDAY) {
            realPayDate = realPayDate.with(TemporalAdjusters.previous(DayOfWeek.FRIDAY));
        }
        return realPayDate;
    }
}

public static void main(String[] args) {
    LocalDate payDate = LocalDate.of(2021,5,18);
    LocalDate realPayDate = LocalDate.from(new PayDayAdjuster().adjustInto(payDate));
    System.out.println("實際發薪日：" + realPayDate);
}

TemporalQuery 的應用

學習的時態類物件（LocalDate，LocalTime）都有一個方法叫做 query，可以針對日期進行查詢，

R query(TemporalQuery query)，這個方法是一個泛型方法，回傳的資料就是傳入的泛型類的型別，TemporalQuery 是一個泛型介面，里面有一個抽象方法是 R queryFrom(TemporalAccessor temporal)，TemporalAccessor 是 Temporal 的父介面，實際上也就是 LocalDate 和 LocalDateTime 相關類的頂級父介面，這個 queryFrom 的方法的實作邏輯就是傳入一個日期/時間物件通過自定義邏輯回傳資料，

如果要計劃日期距離某一個特定天數差距多少天，可以自定義類實作 TemporalQuery 介面并且作為引數傳入到 query 方法中，

例：計算當前時間距離下一個勞動節還有多少天？

package com.y2.test1.time;

import java.time.LocalDate;
import java.time.Month;
import java.time.temporal.ChronoUnit;
import java.time.temporal.TemporalAccessor;
import java.time.temporal.TemporalQuery;

public class UtilDayQuery implements TemporalQuery<Long> {
    @Override
    public Long queryFrom(TemporalAccessor temporal) {
        // 1.TemporalAccessor是LocalDate和LocalDatetime的頂級父介面，相當于LocalDate就是這個介面的實作類，將temporal轉換為LocalDate進行使用
        LocalDate now = LocalDate.from(temporal);
        // 2.初始化本年的勞動節日期
        LocalDate laborDate = LocalDate.of(now.getYear(), Month.MAY, 1);
        // 3.判斷當前時間是否已經超過了當年的勞動節，如果超過了當年的勞動節，則laborDay+1年
        if (now.isAfter(laborDate)) {
            laborDate = laborDate.plusYears(1);
        }
        // 4.通過
        long days = ChronoUnit.DAYS.between(now, laborDate);
        return days;
    }
}

public static void main(String[] args) {
    LocalDate now = LocalDate.of(2021,5,2);
    Long days = new UtilDayQuery().queryFrom(now);
    System.out.println("距離下一個勞動節還有" + days + "天");
    LocalDate laborDate = now.plusDays(days);
    System.out.println("下一個勞動節的日期：" + laborDate);
}

5、java.util.Date 與 java.time.LocalDate 的轉換

Java 8 中的 java.time 包中并沒有提供太多的內置方式來轉換 java.util 包中用預處理標準曰期和時間的類，我們可以使用 Instant 類作為中介，也可以使用 java.sql.Date 和 java.sql.Timestamp 類提供的方法進行轉換，

使用 Instant 類將 java.util.Date 轉換為 java.time.LocalDate

java.time 包中并沒有提供很多的方式來進行直接轉換，但是給之前的 Date 類，Calendar 類在 Java1.8 都提供了一個新的方法， 叫做 toInstant，可以將當前物件轉換為 Instant 物件，通過給 Instant 添加時區資訊之后就可以轉換為 LocalDate物件，

public static void main(String[] args) {
    // 初始化Date物件
    Date date = new Date();
    // 1.將Date物件轉換為Instant物件
    Instant instant = date.toInstant();
    // 2.Date類包含日期和時間資訊，但是并不提供時區資訊，和Instant類一樣，通過Instant類的atZone方法添加時區資訊進行轉換
    ZonedDateTime zonedDateTime = instant.atZone(ZoneId.systemDefault());
    // 3.將ZonedDateTime通過toLocalDate方法轉換為LocalDate物件
    LocalDate localDate = zonedDateTime.toLocalDate();
    System.out.println("date : " + date);
    System.out.println("localDate : " + localDate);
}

java.sql.Date 類中的轉換方法使用

java.sql.Date 類中提供直接轉換為 LocalDate 的方法 toLocalDate，

public static void main(String[] args) {
    // 初始化java.sql.Date物件
    Date date = new Date(System.currentTimeMillis());
    LocalDate localDate = date.toLocalDate();
    System.out.println("date : " + date);
    System.out.println("localDate : " + localDate);
}

java.sql.Timestamp 類中的轉換方法使用

TimeStamp 是時間戳物件，通過傳入一個毫秒值物件進行初始化，

public static void main(String[] args) {
    // 初始化java.sql.Timestamp物件
    Timestamp timestamp = new Timestamp(System.currentTimeMillis());
    LocalDateTime localDateTime = timestamp.toLocalDateTime();
    System.out.println("timestamp : " + timestamp);
    System.out.println("localDateTime : " + localDateTime);
}

將 java.util.Date 類轉換為 java.time.LocalDate 類的第二種方法

java.sql.Date 類提供了轉換為 LocalDate 的方法，那么可以將 java.util.Date 先轉換為 java.sql.Date，

通過 java.sql.Date 的構造方法直接傳入一個毫秒值可以構造一個 java.sql.Date 物件，毫秒值可以通過 java.util.Date 物件的 getTime 方法獲取到，

public static void main(String[] args) {
    Date date = new Date();
    java.sql.Date date1 = new java.sql.Date(date.getTime());
    LocalDate localDate = date1.toLocalDate();
    System.out.println("java.util.date : " + date);
    System.out.println("java.sql.date : " + date1);
    System.out.println("localDate : " + localDate);
}

將 java.util.Calendar 類轉換為 java.time.ZonedDateTime 類

Calendar 物件自 Java1.1 開始提供了一個方法獲取時區物件的方法 getTimeZone，要將 Calendar 物件轉換為 ZonedDateTime 需要先獲取到時區物件，從 Java 1.8 開始 TimeZone 類提供了一個方法可以獲取到 ZonedId，獲取到 ZoneId 之后就可以初始化 ZonedDateTime 物件了，ZonedDateTime 類有一個 ofInstant 方法，可以將一個 Instant 物件和 ZonedId 物件作為引數傳入構造一個 ZonedDateTime 物件，

public static void main(String[] args) {
    Calendar calendar = Calendar.getInstance();
    TimeZone timeZone = calendar.getTimeZone();
    ZoneId zoneId = timeZone.toZoneId();
    ZonedDateTime zonedDateTime = ZonedDateTime.ofInstant(calendar.toInstant(), zoneId);
    System.out.println("calendar : " + calendar);
    System.out.println("zonedDateTime : " + zonedDateTime);
}

將 java.util.Calendar 類轉換為 java.time.LocalDateTime 類

Calendar 物件可以獲取到年月日時分秒的資訊，這些資訊可以作為 LocalDateTime 構造方法的引數，

public static void main(String[] args) {
    Calendar calendar = Calendar.getInstance();
    int year = calendar.get(Calendar.YEAR);
    int month = calendar.get(Calendar.MONTH);
    int day = calendar.get(Calendar.DAY_OF_MONTH);
    int hour = calendar.get(Calendar.HOUR);
    int minute = calendar.get(Calendar.MINUTE);
    int second = calendar.get(Calendar.SECOND);
    LocalDateTime localDateTime = LocalDateTime.of(year, month + 1, day, hour, minute, second);
    System.out.println("calendar : " + calendar);
    System.out.println("localDateTime : " + localDateTime);
}

6、日期的決議與格式化 DateTimeFormatter

SimpleDateFormat 類在剛開始的講過了是執行緒不安全的，所以 Java8 提供了新的格式化類 DateTimeFormatter，

DateTimeFormatter 類提供了大量預定義格式化器，包括常量（如 ISO_LOCAL_DATE），模式字母（如 yyyy-MM-dd）以及本地化樣式，

與 SimpleDateFormat 不同的是，新版本的日期/時間 API 的格式化與決議不需要在創建轉換器物件再進行轉換了，通過時間日期物件的 parse/format 方法可以直接進行轉換，

LocalDate 類定義的 parse 和 format 方法

public static void main(String[] args) {
    // 格式化
    LocalDateTime now = LocalDateTime.now();
    String s1 = now.format(DateTimeFormatter.ISO_DATE_TIME);
    String s2 = now.format(DateTimeFormatter.ISO_DATE);
    System.out.println("now : " + now);
    System.out.println("ISO_DATE_TIME格式化：" + s1);
    System.out.println("ISO_DATE格式化：" + s2);

    // 決議
    LocalDateTime localDateTime = LocalDateTime.parse(s1);
    LocalDate localDate = LocalDate.parse(s2);
    System.out.println("localDateTime : " + localDateTime);
    System.out.println("localDate : " + localDate);
}

對日期決議格式化

通過 DateTimeFormatter 的 ofLocalizedDate 的方法也可以調整格式化的方式，

此方法需要傳入一個 FormatStyle 類物件，查看后發現 FormatStyle 物件是一個列舉類，其中有幾種方式如下：

• Full：全顯示（年月日 + 星期）
• Long：全顯示（年月日）
• Medium：縮略顯示（沒有年月日漢字）
• SHORT：精簡顯示（精簡年 + 月日）

public static void main(String[] args) {
    // 格式化
    LocalDateTime now = LocalDateTime.now();
    String r1 = now.format(DateTimeFormatter.ofLocalizedDate(FormatStyle.FULL));
    String r2 = now.format(DateTimeFormatter.ofLocalizedDate(FormatStyle.LONG));
    String r3 = now.format(DateTimeFormatter.ofLocalizedDate(FormatStyle.MEDIUM));
    String r4 = now.format(DateTimeFormatter.ofLocalizedDate(FormatStyle.SHORT));
    System.out.println("FULL : " + r1);
    System.out.println("LONG : " + r2);
    System.out.println("MEDIUM : " + r3);
    System.out.println("SHORT : " + r4);
}

注意此種方式在不同時區的顯示方式不一樣，在其他時區不會顯示中文，會根據當前系統的默認時區來進行區別顯示，

自定義格式化格式

除了系統的自帶的方式之外，也可以通過 DateTimeFormatter 類提供的 ofPattern 方式創建自定時格式化器，格式化的寫法與之前使用的 SimpleDateFormat 相同，

public static void main(String[] args) {
    // 格式化
    LocalDateTime now = LocalDateTime.now();
    String s = now.format(DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss:SSS"));
    System.out.println("格式化后：" + s);
}

歡迎觀看，感謝支持！！！