Java 8（七）：新的Date 和 Time API

左手的ㄟ右手 2021-11-10 08:56 258阅读 0赞

### 文章目录 ###

*   *  1、为什么会引入新的API
     *  2、java.time 包
     *   *  2.1、java.time
         *  2.2、java.time.chrono
         *  2.3、java.time.format
         *  2.4、java.time.temporal
         *  2.5、java.time.zone
     *  3、用于表示本地日期和时区的新类
     *   *  3.1、java.time.LocalDate
         *   *  3.1.1、创建当前日期和特定日期
             *  3.1.2、从LocalDate获取年，月，日
             *  3.1.3、向LocalDate添加或减去天，月，周和年
             *  3.1.4、比较LocalDate对象
             *  3.1.5、从LocalDate获取月或年的天数
             *  3.1.6、检查给定年份是否为闰年
             *  3.1.7、将String转换为LocalDate的API
             *  3.1.8、将LocalDate转换为java中的String
         *  3.2、java.time.LocalTime
         *   *  3.2.1、LocalTime 对象创建
             *  3.2.2、从LocalTime获取Hour，Minute，Second 方法
             *  3.2.3、向LocalTime添加或减去小时，分钟和秒 方法
             *  3.2.4、比较Java中的LocalTime对象的方法
             *  3.2.5、将String转换为LocalTime的方法
             *  3.2.6、将LocalTime转换为String的方法
         *  3.3、LocalDateTime
         *   *  3.3.1、从LocalDateTime获取当前日期时间和特定日期时间对象
             *  3.3.2、从LocalDateTime获取年，月，日
             *  3.3.3、从LocalDateTime获取Hour，Minute，Second
             *  3.3.4、用LocalDateTime添加或减去年，月，日，小时，分钟和秒
             *  3.3.5、比较Java中的LocalDateTime对象
             *  3.3.6、从LocalDateTime转换为LocalDate
             *  3.3.7、从LocalDateTime转换为LocalTime
     *  4、用于表示时间戳（timestamp ）和持续时间（duration）的新类
     *   *  4.1、Instant
         *  4.2、Duration
         *  4.3、Period

## 1、为什么会引入新的API ##

在旧版的 Java 中，日期时间 API 存在很多问题：

**非线程安全**

java.util.Date 是非线程安全的，所有的日期类都是可变的，这是Java日期类最大的问题之一。

**设计很差**  
Java的日期/时间类的定义并不一致，在java.util和java.sql的包中都有日期类，此外用于格式化和解析的类在java.text包中定义。java.util.Date同时包含日期和时间，而java.sql.Date仅包含日期，将其纳入java.sql包并不合理。另外这两个类都有相同的名字，这本身就是一个非常糟糕的设计。

**时区处理繁琐**

日期类并不提供国际化，没有时区支持，因此Java引入了java.util.Calendar和java.util.TimeZone类，但他们同样存在上述所有的问题。

JDK 1.8 中的新日期和时间API解决了旧API中的许多问题，并且借鉴了 Joda Time API 。新的java.time 包涵盖了所有处理日期，时间，日期/时间，时区，时刻（instants），过程（during）与时钟（clock）的操作。

## 2、java.time 包 ##

JDK 1.8 引入了五个新的日期和时间API包，如下：

### 2.1、java.time ###

这是新的Java日期/时间API的基础包，它是基于ISO-8601标准的API，所有的主要基础类都是这个包的一部分，如：LocalDate, LocalTime, LocalDateTime, Instant, Period, Duration等等。所有这些类都是不可变的和线程安全的，在绝大多数情况下，这些类能够有效地处理一些公共的需求。

### 2.2、java.time.chrono ###

java.time.chrono 包含日历API。 这适用于需要使用本地化日历的应用程序。 为Hijrah，Japanese，Minguo和ThaiBuddhist日历提供支持。我们可以扩展AbstractChronology类来创建自己的日历系统。

### 2.3、java.time.format ###

java.time.format 包含能够格式化和解析日期时间对象的API，可以通过各种方式创建格式化程序，包括常量，模式，本地化样式和构建器。 格式化程序是不可变的和线程安全的。

### 2.4、java.time.temporal ###

java.time.temporal包含用于访问日期时间字段和单位的API。单位是可衡量的，例如年，月和小时。例如，表达“2小时后”使用小时单位。例如，年的月份（month-of-year），星期几（day-of-week）和小时（hour-of-day ）都是字段。如果需要，可以通过应用程序扩展受支持的单元和字段集。

### 2.5、java.time.zone ###

java.time.zone包含处理时区的API。 提供有关每个时区规则的详细信息。

## 3、用于表示本地日期和时区的新类 ##

### 3.1、java.time.LocalDate ###

LocalDate 类表示日期。 没有时间或时区的表示。是一个不可变的类，它表示默认格式(yyyy-MM-dd)的日期，我们可以使用now()方法得到当前时间，也可以提供输入年份、月份和日期的输入参数来创建一个LocalDate实例。该类为now()方法提供了重载方法，我们可以传入ZoneId来获得指定时区的日期,该类提供与java.sql.Date相同的功能.

#### 3.1.1、创建当前日期和特定日期 ####

LocalDate类提供以下API以创建当前日期和特定日期。

*  static LocalDate now() - 在默认时区中从系统时钟获取当前日期。
 *  static LocalDate now(Clock clock) - 从指定的时钟获取当前日期。
 *  static LocalDate now(ZoneId zone) - 从指定时区的系统时钟获取当前日期。
 *  static LocalDate of(int year, int month, int dayOfMonth) - 从年，月和日获得LocalDate的实例。
 *  static LocalDate of(int year, Month month, int dayOfMonth) - 从年，月和日获得LocalDate的实例。

/**
         * 创建当前日期和特定日期
         */
        public static void createLocalDate() {
            // 在默认时区中从系统时钟获取当前日期。
            LocalDate localDate = LocalDate.now();
            System.out.println("LocalDate.now()：" + localDate);
            // 从指定的时钟获取当前日期。
            LocalDate localDate1 = LocalDate.now(Clock.systemDefaultZone());
            System.out.println("LocalDate.now(Clock.systemDefaultZone())：" + localDate1);
            // 从指定时区的系统时钟获取当前日期。
            LocalDate localDate3 = LocalDate.now(Clock.system(ZoneId.of("Indian/Cocos")));
            System.out.println("LocalDate.now(Clock.system(ZoneId.of(\"Indian/Cocos\")))：" + localDate3);
            // 从年，月和日获得LocalDate的实例。
            LocalDate localDate2 = LocalDate.of(1991, Month.MARCH, 24);
            System.out.println("LocalDate.of(1991, Month.MARCH, 24)：" + localDate2);
            // 从年，月和日获得LocalDate的实例。
            LocalDate localDate5 = LocalDate.of(1991, 12, 24);
            System.out.println("LocalDate.of(1991, 12, 24)：" + localDate5);
        }

输出：

LocalDate.now()：2019-07-28
    LocalDate.now(Clock.systemDefaultZone())：2019-07-28
    LocalDate.now(Clock.system(ZoneId.of("Indian/Cocos")))：2019-07-28
    LocalDate.of(1991, Month.MARCH, 24)：1991-03-24
    LocalDate.of(1991, 12, 24)：1991-12-24

#### 3.1.2、从LocalDate获取年，月，日 ####

LocalDate类提供以下API以分别获得年，月和日。

*  Month getMonth() - 使用Month枚举获取月份字段。
 *  int getMonthValue() - 获取1到12之间的月份字段。
 *  int getYear() - 获取年份字段。
 *  int getDayOfMonth() - 获取日期字段。
 *  DayOfWeek getDayOfWeek() - 获取星期几字段，即枚举DayOfWeek。
 *  int getDayOfYear() - 获取日期字段。

/**
         * 从LocalDate获取年，月，日
         */
        public static void getYearMonthDay() {
            LocalDate localDate = LocalDate.now();
            System.out.println("Year : " + localDate.getYear());
            System.out.println("Month : " + localDate.getMonth().getValue());
            System.out.println("Day of Month : " + localDate.getDayOfMonth());
            System.out.println("Day of Week : " + localDate.getDayOfWeek());
            System.out.println("Day of Year : " + localDate.getDayOfYear());
        }

输出：

Year : 2019
    Month : 7
    Day of Month : 28
    Day of Week : SUNDAY
    Day of Year : 209

#### 3.1.3、向LocalDate添加或减去天，月，周和年 ####

LocalDate类提供以下API以向LocalDate添加或减去Days，Months，Weeks和Years。

*  LocalDate plusDays(long daysToAdd) - 返回此LocalDate的副本，并添加指定的天数。
 *  LocalDate plusMonths(long monthsToAdd) - 返回此LocalDate的副本，并添加指定的月数。
 *  LocalDate plusWeeks(long weeksToAdd) - 返回此LocalDate的副本，并添加指定的周数。
 *  LocalDate plusYears(long yearsToAdd) - 返回此LocalDate的副本，并添加指定的年数。

/**
         * 向LocalDate添加或减去天，月，周和年
         */
        public static void addOrSubstractUsingLocalDate() {
            LocalDate localDate = LocalDate.now();
            // LocalDate 添加指定年月日的方法
            System.out.println("添加 days : " + localDate.plusDays(5));
            System.out.println("添加 months : " + localDate.plusMonths(15));
            System.out.println("添加 weeks : " + localDate.plusWeeks(45));
            System.out.println("添加 years : " + localDate.plusYears(5));
    
            // LocalDate 减去指定年月日的方法
            System.out.println("减去 days : " + localDate.minusDays(5));
            System.out.println("减去 months : " + localDate.minusMonths(15));
            System.out.println("减去 weeks : " + localDate.minusWeeks(45));
            System.out.println("减去 years : " + localDate.minusYears(5));
        }

输出：

添加 days : 2019-08-02
    添加 months : 2020-10-28
    添加 weeks : 2020-06-07
    添加 years : 2024-07-28
    减去 days : 2019-07-23
    减去 months : 2018-04-28
    减去 weeks : 2018-09-16
    减去 years : 2014-07-28

#### 3.1.4、比较LocalDate对象 ####

LocalDate类提供以下API来比较Java中的LocalDate对象。

*  boolean isAfter(ChronoLocalDate other) - 检查此日期是否在指定日期之后。
 *  boolean isBefore(ChronoLocalDate other) - 检查此日期是否在指定日期之前。
 *  boolean isEqual(ChronoLocalDate other) - 检查此日期是否等于指定日期。

/**
         * 比较LocalDate对象
         */
        public static void compareLocalDate() {
            LocalDate localDate1 = LocalDate.now();
            LocalDate localDate2 = LocalDate.of(2017, Month.MAY, 14);
            LocalDate localDate3 = LocalDate.of(2016, Month.MAY, 15);
    
            // isEqual()
            if (localDate1.isEqual(localDate2)) {
                System.out.println("localDate1 等于 localDate2");
            } else {
                System.out.println("localDate1 不等于 localDate2");
            }
    
            // ifAfter()
            if (localDate2.isAfter(localDate3)) {
                System.out.println("localDate2 大于 localDate3");
            }
    
            // isBefore()
            if (localDate3.isBefore(localDate1)) {
                System.out.println("localDate3 小于 localDate1");
            }
        }

输出：

localDate1 不等于 localDate2
    localDate2 大于 localDate3
    localDate3 小于 localDate1

#### 3.1.5、从LocalDate获取月或年的天数 ####

LocalDate类提供以下API，以从LocalDate获取Month或Year的天数。

*  int lengthOfMonth() - 返回此日期表示的月份长度。
 *  int lengthOfYear() - 返回此日期表示的年份长度。

/**
         * 从LocalDate获取月或年的天数
         */
        public static void getDaysFromMonthAndYear() {
            LocalDate localDate1 = LocalDate.of(2017, Month.JANUARY, 1);
            LocalDate localDate2 = LocalDate.of(2016, Month.FEBRUARY, 1);
    
            // Number of days in a month
            System.out.println(localDate1.getMonth() + " 月天数 : " + localDate1.lengthOfMonth());
            System.out.println(localDate2.getMonth() + " 月天数 : " + localDate2.lengthOfMonth());
    
            // Number of days in a year
            System.out.println(localDate1.getYear() + " 年天数 : " + localDate1.lengthOfYear());
            System.out.println(localDate2.getYear() + " 年天数 : " + localDate2.lengthOfYear());
        }

输出：

JANUARY天数 : 31
    FEBRUARY天数 : 29
    2017天数 : 365
    2016天数 : 366

#### 3.1.6、检查给定年份是否为闰年 ####

LocalDate类提供以下API来检查给定年份是否为闰年。

*  boolean isLeapYear() - 根据ISO日历系统规则，检查年份是否为闰年。

/**
         * 检查给定年份是否为闰年
         */
        public static void checkIfYearIsLeapYear() {
            LocalDate localDate1 = LocalDate.of(2017, Month.JANUARY, 1);
            LocalDate localDate2 = LocalDate.of(2016, Month.JANUARY, 1);
    
            if (localDate1.isLeapYear()) {
                System.out.println(localDate1.getYear() + " 是闰年");
            } else {
                System.out.println(localDate1.getYear() + " 不是闰年");
            }
    
            if (localDate2.isLeapYear()) {
                System.out.println(localDate2.getYear() + " 是闰年");
            } else {
                System.out.println(localDate2.getYear() + " 不是闰年");
            }
        }

输出：

2017 不是闰年
    2016 是闰年

#### 3.1.7、将String转换为LocalDate的API ####

LocalDate类提供以下API以在Java中将String转换为LocalDate。

*  static LocalDate parse(CharSequence text) - 从文本字符串（如2007-12-03）获取LocalDate的实例。
 *  static LocalDate parse(CharSequence text, DateTimeFormatter formatter) - 使用特定格式化程序从文本字符串中获取LocalDate的实例。

/**
         * 将String转换为LocalDate的API
         */
        public static void convertStringToLocalDate() {
            // ISO Date
            LocalDate localDate = LocalDate.parse("2017-05-03", DateTimeFormatter.ISO_LOCAL_DATE);
            System.out.println("localDate：" + localDate);
    
            // yyyy/MM/dd pattern
            LocalDate localDate1 = LocalDate.parse("2017/05/12", DateTimeFormatter.ofPattern("yyyy/MM/dd"));
            System.out.println("2017/05/12 格式化：" + localDate1);
    
            // dd-LL-yyyy pattern
            LocalDate localDate4 = LocalDate.parse("12-01-2017", DateTimeFormatter.ofPattern("dd-LL-yyyy"));
            System.out.println("12-01-2017 格式化：" + localDate4);
        }

输出：

localDate：2017-05-03
    2017/05/12 格式化：2017-05-12
    12-01-2017 格式化：2017-01-12

#### 3.1.8、将LocalDate转换为java中的String ####

LocalDate类提供以下API以在Java中将LocalDate转换为String。

*  String format(DateTimeFormatter formatter) - 使用指定的格式化程序格式化此日期。

/**
         * LocalDate 转换为指定日期格式字符串
         */
        public static void convertLocalDatetoString() {
            // ISO Date
            LocalDate localDate = LocalDate.now();
            DateTimeFormatter dateFormatter = DateTimeFormatter.ISO_LOCAL_DATE;
            System.out.println(localDate.format(dateFormatter));
    
            // yyyy/MM/dd pattern
            DateTimeFormatter dateFormatter1 = DateTimeFormatter.ofPattern("yyyy/MM/dd");
            System.out.println(localDate.format(dateFormatter1));
    
            // MMMM dd, yyyy pattern
            DateTimeFormatter dateFormatter2 = DateTimeFormatter.ofPattern("MMMM dd, yyyy");
            System.out.println(localDate.format(dateFormatter2));
    
            // dd-MMM-yyyy pattern
            DateTimeFormatter dateFormatter3 = DateTimeFormatter.ofPattern("dd-MMM-yyyy");
            System.out.println(localDate.format(dateFormatter3));
    
            // dd-LL-yyyy pattern
            DateTimeFormatter dateFormatter4 = DateTimeFormatter.ofPattern("dd-LL-yyyy");
            System.out.println(localDate.format(dateFormatter4));
        }

输出：

2019-08-02
    2019/08/02
    八月 02, 2019
    02-八月-2019
    02-08-2019

### 3.2、java.time.LocalTime ###

LocalTime是一个不可变的类，它的实例代表一个符合人类可读格式的时间，默认格式是hh:mm:ss.zzz。像LocalDate一样，该类也提供了时区支持，同时也可以传入小时、分钟和秒等输入参数创建实例。

#### 3.2.1、LocalTime 对象创建 ####

LocalTime类分别为当前时间和特定时间对象提供以下API。

*  static LocalTime now() - 从默认时区的系统时钟获取当前时间。
 *  static LocalTime now(Clock clock) - 从指定的时钟获得当前时间。
 *  static LocalTime now(ZoneId zone) - 从指定时区的系统时钟获取当前时间。

private static void createLocalTime() {
            // 当前时间
            LocalTime localTime = LocalTime.now();
            System.out.println("当前时间："+localTime);
    
            // 指定时间
            LocalTime localTime2 = LocalTime.of(4, 30, 45);
            System.out.println("指定时间："+localTime2);
    
            //当前时钟默认时区
            LocalTime localTime3 = LocalTime.now(Clock.systemDefaultZone());
            System.out.println("当前时钟默认时区："+localTime3);
            //指定时区
            LocalTime localTime4 = LocalTime.now(Clock.system(ZoneId.of("Asia/Shanghai")));
            System.out.println("指定时区："+localTime4);
        }

输出：

当前时间：14:28:22.976
    指定时间：04:30:45
    当前时钟默认时区：14:28:22.976
    指定时区：14:28:22.976

#### 3.2.2、从LocalTime获取Hour，Minute，Second 方法 ####

LocalTime类提供以下API从LocalTime获取Hour，Minute，Second。

*  int getHour() - 获取小时（ hour-of-day）
 *  int getMinute() - 获取分钟（minute-of-hour）
 *  int getNano() - 获取纳秒（nano-of-second）
 *  int getSecond() - 获取秒（second-of-minute ）

/**
         * LocalTime 获取时分秒方法
         */
        public static void getHourMinuteSecondfromLocalTime() {
            LocalTime localTime = LocalTime.now();
            System.out.println("获取 hour-of-day : " + localTime.getHour());
            System.out.println("获取 minute-of-hour : " + localTime.getMinute());
            System.out.println("获取 second-of-minute : " + localTime.getSecond());
            System.out.println("获取nano-of-second : " + localTime.getNano());
        }

输出：

获取 hour-of-day : 14
    获取 minute-of-hour : 34
    获取 second-of-minute : 30
    获取nano-of-second : 73000000

#### 3.2.3、向LocalTime添加或减去小时，分钟和秒 方法 ####

LocalTime类提供以下API以向LocalTime添加或减去小时，分钟和秒。

*  LocalTime plusHours(long hoursToAdd) - 返回此LocalTime的副本，并添加指定的小时数。
 *  LocalTime plusMinutes(long minutesToAdd) - 返回此LocalTime的副本，并添加指定的分钟数。
 *  LocalTime plusNanos(long nanosToAdd) - 返回此LocalTime的副本，并添加指定的纳秒数。
 *  LocalTime plusSeconds(long secondstoAdd) - 返回此LocalTime的副本，并添加指定的秒数。
 *  LocalTime minusHours(long hoursToSubtract) - 返回此LocalTime的副本，并减去指定的小时数。
 *  LocalTime minusMinutes(long minutesToSubtract) - 返回此LocalTime的副本，并减去指定的分钟数。
 *  LocalTime minusNanos(long nanosToSubtract) - 返回此LocalTime的副本，并减去指定的纳秒数。
 *  LocalTime minusSeconds(long secondsToSubtract) -返回此LocalTime的副本，并减去指定的秒数。

/**
         * LocalTime 向LocalTime添加或减去小时，分钟和秒
         */
        public static void addorSubtractHoursMinutesAndSecondstoLocalTime() {
            LocalTime localTime = LocalTime.now();
            System.out.println("当前时间 : " + localTime);
    
            // LocalTime 加法运算
            System.out.println("加上指定小时 : " + localTime.plusHours(2));
            System.out.println("加上指定分钟 : " + localTime.plusMinutes(30));
            System.out.println("加上指定秒数 : " + localTime.plusSeconds(20));
            System.out.println("加上指定纳秒 : " + localTime.plusNanos(60000));
    
            // LocalTime 减法运算
            System.out.println("减去指定小时 : " + localTime.minusHours(2));
            System.out.println("减去指定分钟 : " + localTime.minusMinutes(30));
            System.out.println("减去指定秒数 : " + localTime.minusSeconds(20));
            System.out.println("减去指定纳秒 : " + localTime.minusNanos(60000));
        }

输出：

当前时间 : 14:44:08.708
    加上指定小时 : 16:44:08.708
    加上指定分钟 : 15:14:08.708
    加上指定秒数 : 14:44:28.708
    加上指定纳秒 : 14:44:08.708060
    减去指定小时 : 12:44:08.708
    减去指定分钟 : 14:14:08.708
    减去指定秒数 : 14:43:48.708
    减去指定纳秒 : 14:44:08.707940

#### 3.2.4、比较Java中的LocalTime对象的方法 ####

LocalTime类提供以下API来比较Java中的LocalTime对象。

*  int compareTo(LocalTime other) - 比较这个时间到另一个时间。
 *  boolean isAfter(LocalTime other) - 检查此时间是否在指定时间之后。
 *  boolean isBefore(LocalTime other) - 检查此时间是否在指定时间之前。

/**
         * 比较Java中的LocalTime对象的方法
         */
        public static void compareLocalTimeObjects() {
            LocalTime localTime1 = LocalTime.of(9, 10, 50);
            LocalTime localTime2 = LocalTime.of(9, 10, 50);
            LocalTime localTime3 = LocalTime.of(11, 45, 20);
    
            // compareTo()
            if (localTime1.compareTo(localTime2) == 0) {
                System.out.println("localTime1 和 localTime2 相等");
            } else {
                System.out.println("localTime1 和 localTime2 不相等");
            }
    
            // isBefore()
            if (localTime2.isBefore(localTime3)) {
                System.out.println("localTime2 小于 localTime3");
            }
    
            // isAfter()
            if (localTime3.isAfter(localTime1)) {
                System.out.println("localTime3 大于 localTime1");
            }
        }

输出：

localTime1 和 localTime2 相等
    localTime2 小于 localTime3
    localTime3 大于 localTime1

#### 3.2.5、将String转换为LocalTime的方法 ####

LocalTime类提供以下API以在java中将String转换为LocalTime。

*  static LocalTime parse(CharSequence text) - 从例如10:15的文本字符串中获取LocalTime的实例。
 *  static LocalTime parse(CharSequence text, DateTimeFormatter formatter) - 使用特定格式化程序从文本字符串中获取LocalTime的实例。

/**
         * 将String转换为LocalTime的方法
         */
        public static void convertStringToLocalTime() {
            LocalTime isoTime = LocalTime.parse("10:15:30", DateTimeFormatter.ISO_LOCAL_TIME);
            System.out.println("isoTime：" + isoTime);
    
            // hour-of-day (0-23)
            LocalTime localTime = LocalTime.parse("22:45:30", DateTimeFormatter.ofPattern("HH:mm:ss"));
            System.out.println("hour-of-day (0-23)：" + localTime);
    
            // clock-hour-of-am-pm (1-24)
            LocalTime localTime2 = LocalTime.parse("22:45:30", DateTimeFormatter.ofPattern("kk:mm:ss"));
            System.out.println("clock-hour-of-am-pm (1-24)：" + localTime2);
        }

输出：

isoTime：10:15:30
    hour-of-day (0-23)：22:45:30
    clock-hour-of-am-pm (1-24)：22:45:30

#### 3.2.6、将LocalTime转换为String的方法 ####

LocalTime类提供以下API以在java中将LocalTime转换为String。

*  String format(DateTimeFormatter formatter) - 这次使用指定的格式化程序格式化。

/**
         * 将LocalTime转换为String的方法
         */
        public static void convertLocalTimeToString() {
            LocalTime localTime = LocalTime.now();
    
            // ISO Format
            DateTimeFormatter timeFormatter = DateTimeFormatter.ISO_LOCAL_TIME;
            System.out.println("ISO Format：" + localTime.format(timeFormatter));
    
            // hour-of-day (0-23)
            DateTimeFormatter timeFormatter1 = DateTimeFormatter
                    .ofPattern("HH:mm:ss");
            System.out.println("hour-of-day (0-23)：" + localTime.format(timeFormatter1));
    
            // clock-hour-of-am-pm (1-24)
            DateTimeFormatter timeFormatter2 = DateTimeFormatter
                    .ofPattern("kk:mm:ss");
            System.out.println("clock-hour-of-am-pm (1-24)：" + localTime.format(timeFormatter2));
    
            // clock-hour-of-am-pm (1-12)
            DateTimeFormatter timeFormatter3 = DateTimeFormatter
                    .ofPattern("hh:mm:ss a");
            System.out.println("clock-hour-of-am-pm (1-12)：" + localTime.format(timeFormatter3));
    
            // hour-of-am-pm (0-11)
            DateTimeFormatter timeFormatter4 = DateTimeFormatter
                    .ofPattern("KK:mm:ss a");
            System.out.println("hour-of-am-pm (0-11)：" + localTime.format(timeFormatter4));
        }

输出：

ISO Format：14:59:54.337
    hour-of-day (0-23)：14:59:54
    clock-hour-of-am-pm (1-24)：14:59:54
    clock-hour-of-am-pm (1-12)：02:59:54 下午
    hour-of-am-pm (0-11)：02:59:54 下午

### 3.3、LocalDateTime ###

LocalDateTime 是一个不可变的日期-时间对象，它用于表示日期和时间的组合，默认格式是yyyy-MM-dd-HH-mm-ss.zzz。它提供了一个工厂方法，接收LocalDate和LocalTime输入参数，创建LocalDateTime实例。

#### 3.3.1、从LocalDateTime获取当前日期时间和特定日期时间对象 ####

*  static LocalDateTime now() - 从默认时区中的系统时钟获取当前日期时间。
 *  static LocalDateTime now(Clock clock) -从指定的时钟获得当前日期时间。
 *  static LocalDateTime now(ZoneId zone) - 从指定时区的系统时钟获取当前日期时间。

/**
         * 创建 LocalDateTime 对象
         */
        public static void createLocalDateTime() {
            // 获取当前的日期时间对象
            LocalDateTime dateTime = LocalDateTime.now();
            System.out.println(dateTime);
    
            // 从指定时区获取当前的日期时间对象
            LocalDateTime dateTime2 = LocalDateTime.now(ZoneId.of("UTC"));
            System.out.println(dateTime2);
    
            // 从指定时钟获取当前的日期时间对象
            LocalDateTime dateTime3 = LocalDateTime.now(Clock.systemUTC());
            System.out.println(dateTime3);
    
            // 获取指定的日期时间对象
            LocalDateTime dateTime4 = LocalDateTime.of(2017, Month.JULY, 12, 10, 35, 55);
            System.out.println(dateTime4);
        }

输出：

2019-08-02T13:15:56.786
    2019-08-02T05:15:56.787
    2019-08-02T05:15:56.787
    2017-07-12T10:35:55

#### 3.3.2、从LocalDateTime获取年，月，日 ####

*  int getYear() - 获取年
 *  Month getMonth() - 使用Month枚举获取月份字段。
 *  int getDayOfMonth() - 获取 day-of-month
 *  DayOfWeek getDayOfWeek() - 获取星期几字段，即枚举DayOfWeek。
 *  int getDayOfYear() - 获取 day-of-year

/**
         * 从LocalDateTime获取年，月，日
         */
        public static void getYearMonthDayFromLocalDateTime() {
            LocalDateTime dateTime = LocalDateTime.now();
            System.out.println("Year : " + dateTime.getYear());
            System.out.println("Month : " + dateTime.getMonth().getValue());
            System.out.println("Day of Month : " + dateTime.getDayOfMonth());
            System.out.println("Day of Week : " + dateTime.getDayOfWeek());
            System.out.println("Day of Year : " + dateTime.getDayOfYear());
        }

输出：

Year : 2019
    Month : 8
    Day of Month : 2
    Day of Week : FRIDAY
    Day of Year : 214

#### 3.3.3、从LocalDateTime获取Hour，Minute，Second ####

*  int getHour() - 获取小时，hour-of-day
 *  int getMinute() - 获取分钟，minute-of-hour
 *  int getNano() - 获取纳秒，nano-of-second
 *  int getSecond() - 获取秒，second-of-minute

/**
         * 从LocalDateTime获取Hour，Minute，Second
         */
        public static void getHourMinuteSecondfromLocalDateTime() {
            LocalDateTime dateTime = LocalDateTime.now();
            System.out.println("Hour（小时） : " + dateTime.getHour());
            System.out.println("Minute （分钟）: " + dateTime.getMinute());
            System.out.println("Second （秒）: " + dateTime.getSecond());
            System.out.println("Nano : （纳秒）" + dateTime.getNano());
        }

输出：

Hour（小时） : 13
    Minute （分钟）: 24
    Second （秒）: 19
    Nano : （纳秒）326000000

#### 3.3.4、用LocalDateTime添加或减去年，月，日，小时，分钟和秒 ####

*  LocalDateTime plusDays(long days) - 返回此LocalDateTime的副本，并添加指定的天数。
 *  LocalDateTime plusHours(long hours) - 返回此LocalDateTime的副本，并添加指定的小时数。
 *  LocalDateTime plusMinutes(long minutes) - 返回此LocalDateTime的副本，并添加指定的分钟数。
 *  LocalDateTime plusMonths(long months) - 返回此LocalDateTime的副本，并添加指定的月数。
 *  LocalDateTime plusNanos(long nanos) - 返回此LocalDateTime的副本，其中添加了指定的纳秒数。
 *  LocalDateTime plusSeconds(long seconds) - 返回此LocalDateTime的副本，并添加指定的秒数。
 *  LocalDateTime plusWeeks(long weeks) - 返回此LocalDateTime的副本，并添加指定的周数。
 *  LocalDateTime plusYears(long years) - 返回此LocalDateTime的副本，其中添加了指定的年数。
 *  LocalDateTime minusDays(long days) - 返回此LocalDateTime的副本，并减去指定的天数。
 *  LocalDateTime minusHours(long hours) - 返回此LocalDateTime的副本，并减去指定的小时数。
 *  LocalDateTime minusMinutes(long minutes) - 返回此LocalDateTime的副本，并减去指定的分钟数。
 *  LocalDateTime minusMonths(long months) - 返回此LocalDateTime的副本，并减去指定的月数。
 *  LocalDateTime minusNanos(long nanos) - 返回此LocalDateTime的副本，减去指定的纳秒数。
 *  LocalDateTime minusSeconds(long seconds) - 返回此LocalDateTime的副本，并减去指定的秒数。
 *  LocalDateTime minusWeeks(long weeks) - 返回此LocalDateTime的副本，并减去指定的周数。
 *  LocalDateTime minusYears(long years) - 返回此LocalDateTime的副本，并减去指定的年数。

/**
         * 用LocalDateTime添加或减去年，月，日，小时，分钟和秒
         */
        public static void addOrSubstractUsingLocalDateTime() {
            LocalDateTime dateTime = LocalDateTime.now();
            // LocalDateTime 加法运算
            System.out.println("加指定天数 : " + dateTime.plusDays(5));
            System.out.println("加指定月数 : " + dateTime.plusMonths(15));
            System.out.println("加指定年数 : " + dateTime.plusYears(5));
            System.out.println("加上指定小时数: " + dateTime.plusHours(2));
            System.out.println("加上指定分钟数 : " + dateTime.plusMinutes(30));
            System.out.println("加上指定秒杀 : " + dateTime.plusSeconds(20));
    
            // LocalDateTime 减法运算
            System.out.println("减去指定天数 : " + dateTime.minusDays(5));
            System.out.println("减去指定月数 : " + dateTime.minusMonths(15));
            System.out.println("减去指定年数 : " + dateTime.minusYears(5));
            System.out.println("减去指定小时数 : " + dateTime.minusHours(2));
            System.out.println("减去指定分钟数 : " + dateTime.minusMinutes(30));
            System.out.println("减去指定秒数 : " + dateTime.minusSeconds(20));
        }

输出：

加指定天数 : 2019-08-07T13:32:40.395
    加指定月数 : 2020-11-02T13:32:40.395
    加指定年数 : 2024-08-02T13:32:40.395
    加上指定小时数: 2019-08-02T15:32:40.395
    加上指定分钟数 : 2019-08-02T14:02:40.395
    加上指定秒杀 : 2019-08-02T13:33:00.395
    减去指定天数 : 2019-07-28T13:32:40.395
    减去指定月数 : 2018-05-02T13:32:40.395
    减去指定年数 : 2014-08-02T13:32:40.395
    减去指定小时数 : 2019-08-02T11:32:40.395
    减去指定分钟数 : 2019-08-02T13:02:40.395
    减去指定秒数 : 2019-08-02T13:32:20.395

#### 3.3.5、比较Java中的LocalDateTime对象 ####

*  boolean isAfter(ChronoLocalDateTime<?> other) - 检查此日期时间是否大于指定的日期时间。
 *  boolean isBefore(ChronoLocalDateTime<?> other) - 检查此日期时间是否小于指定的日期时间。
 *  boolean isEqual(ChronoLocalDateTime<?> other) - 检查此日期时间是否等于指定的日期时间。
 *  int compareTo(ChronoLocalDateTime<?> other) - 将此日期时间与另一个日期时间进行比较。

/**
         * 比较Java中的LocalDateTime对象
         */
        public static void compareLocalDateTimeObjects() {
            LocalDateTime dateTime1 = LocalDateTime.of(2019, 07, 22, 10, 55, 25);
            LocalDateTime dateTime2 = LocalDateTime.of(2018, 04, 11, 05, 35, 26);
            LocalDateTime dateTime3 = LocalDateTime.of(2017, 12, 22, 10, 55, 25);
    
            // isBefore()
            if (dateTime1.isBefore(dateTime2)) {
                System.out.println("dateTime1 小于 dateTime2");
            }
    
            // isAfter()
            if (dateTime2.isAfter(dateTime3)) {
                System.out.println("dateTime2 大于 dateTime3");
            }
    
            // isEqual()
            if (dateTime1.isEqual(dateTime3)) {
                System.out.println("dateTime1 等于 dateTime3");
            }
    
            // compareTo()
            if (dateTime1.compareTo(dateTime3) == 0) {
                System.out.println("dateTime1 等于 dateTime3");
            }
    
        }

输出：

dateTime2 大于 dateTime3

#### 3.3.6、从LocalDateTime转换为LocalDate ####

*  LocalDate toLocalDate() - 获取此日期时间的LocalDate部分。

/**
         * 从LocalDateTime转换为LocalDate
         * */
        public static void convertLocalDateTimeToLocalDate() {
            LocalDateTime dateTime = LocalDateTime.now();
            System.out.println("当前时间："+dateTime);
    
            LocalDate localDate = dateTime.toLocalDate();
            System.out.println("获取日期部分："+localDate);
        }

输出：

当前时间：2019-08-02T13:40:53.887
    获取日期部分：2019-08-02

#### 3.3.7、从LocalDateTime转换为LocalTime ####

*  LocalTime toLocalTime() - 获取此日期时间的LocalTime部分。

/**
         * 从LocalDateTime转换为LocalTime
         */
        public static void convertLocalDateTimeToLocalTime() {
            LocalDateTime dateTime = LocalDateTime.now();
            System.out.println("当前日期时间：" + dateTime);
    
            LocalTime localDate = dateTime.toLocalTime();
            System.out.println("当前时间部分：" + localDate);
        }

输出：

当前日期时间：2019-08-02T13:42:41.219
    当前时间部分：13:42:41.219

## 4、用于表示时间戳（timestamp ）和持续时间（duration）的新类 ##

### 4.1、Instant ###

nstant类是用在机器可读的时间格式上的，它以Unix时间戳的形式存储日期时间

public static void instantMethod() {
            Instant instant = Instant.parse("2019-08-02T10:37:30.00Z");
            Instant minmus2Days=  instant.minus(Duration.ofDays(2));
            Instant pulus5Days=  instant.plus(Duration.ofDays(5));
    
            System.out.println("Instant 对象实例："+instant);
            System.out.println("Instant 减去2天："+minmus2Days);
            System.out.println("Instant 加上5天："+pulus5Days);
            System.out.println("Instant 是否支持单位DAYS："+instant.isSupported(ChronoUnit.DAYS));
            System.out.println("Instant 是否支持单位YEARS："+instant.isSupported(ChronoUnit.YEARS));
        }

输出：

Instant 对象实例：2019-08-02T10:37:30Z
    Instant 减去2天：2019-07-31T10:37:30Z
    Instant 加上5天：2019-08-07T10:37:30Z
    Instant 是否支持单位DAYS：true
    Instant 是否支持单位YEARS：false

### 4.2、Duration ###

Duration 最适合测量基于机器的时间的情况，例如使用Instant对象的代码。

Duration 对象以秒或纳秒为单位测量，并且不使用基于日期的构造，例如年，月和日，尽管该类提供了转换为天，小时和分钟的方法。

Duration 提供了很多API/方法来处理持续时间。我们将讨论一些重要且经常使用的API 方法。

public static void durationMethod() {
            Duration d1 = Duration.between(LocalTime.MAX, LocalTime.NOON);
            Duration d2 = Duration.between(LocalTime.NOON, LocalTime.MAX);
            System.out.println("d1 是否是负数：" + d1.isNegative());
            System.out.println("d2 是否是负数：" + d2.isNegative());
            System.out.println("d1 与 d2 相差秒数：" + d1.get(ChronoUnit.SECONDS));
            System.out.println("d1 加上 d2 ：" + d1.plus(d2).getSeconds());
            System.out.println("d1 减去 d2 ：" + d1.minus(d2).getSeconds());
        }

输出：

d1 是否是负数：true
    d2 是否是负数：false
    d1 与 d2 相差秒数：-43200
    d1 加上 d2 ：0
    d1 减去 d2 ：-86400

### 4.3、Period ###

Period 类表示以年，月和日为单位的时间量。 这个类是不可变的和线程安全的。

public class PeriodDemo {
        public static void periodMethod() {
            withYearsMethodExample();
    
            withMonthsMethodExample();
    
            withDaysMethodExample();
    
            toTotalMonthsMethodExample();
    
            subtractFromMethodExample();
    
            plusYearsMethodExample();
    
            plusMonthsMethodExample();
    
            plusDaysMethodExample();
    
            plusMethodExample();
    
            parseMethodExample();
    
            ofYearsMethodExample();
    
            ofWeeksMethodExample();
    
            ofMonthsMethodExample();
    
            ofDaysMethodExample();
    
            ofMethodExample();
    
            minusYearsMethodExample();
    
            minusMonthsMethodExample();
    
            minusDaysMethodExample();
        }
    
        public static void withYearsMethodExample() {
            Period period = Period.ofYears(2);
            System.out.println("Period.ofYears(2)：" + period.toString());
            period = period.withYears(5);
            System.out.println("period.withYears(5)：" + period.toString());
        }
    
        public static void withMonthsMethodExample() {
            Period period = Period.ofMonths(2);
            System.out.println("Period.ofMonths(2)：" + period.toString());
            period = period.withMonths(5);
            System.out.println("period.withMonths(5)：" + period.toString());
        }
    
        public static void withDaysMethodExample() {
            Period period = Period.ofDays(2);
            System.out.println("Period.ofDays(2)：" + period.toString());
            period = period.withDays(5);
            System.out.println("period.withDays(5)：" + period.toString());
        }
    
        public static void toTotalMonthsMethodExample() {
            Period period = Period.ofYears(2);
            System.out.println("Period.ofYears(2)：" + period.toTotalMonths());
        }
    
        public static void subtractFromMethodExample() {
            Period period = Period.ofYears(2);
    
            LocalDateTime date = LocalDateTime.now();
            System.out.println(date);
    
            date = (LocalDateTime) period.subtractFrom(date);
            System.out.println(date);
        }
    
        public static void plusYearsMethodExample() {
            Period period = Period.ofYears(2);
            Period period1 = period.plusYears(1);
            System.out.println("Period.ofYears(2).plusYears(1)：" + period1.getYears());
        }
    
        public static void plusMonthsMethodExample() {
            Period period = Period.ofMonths(2);
            Period period1 = period.plusMonths(1);
            System.out.println("Period.ofMonths(2).plusMonths(1)：" + period1.getMonths());
        }
    
        public static void plusDaysMethodExample() {
            Period period = Period.ofDays(2);
            Period period1 = period.plusDays(1);
            System.out.println("Period.ofDays(2).plusDays(1)：" + period1.getDays());
        }
    
        public static void plusMethodExample() {
            Period period = Period.of(1, 5, 2);
            System.out.println(
                    "Years: " + period.getYears() + ", Months: " + period.getMonths() + ", Days: " + period.getDays());
            Period period1 = period.plus(Period.ofDays(5));
            System.out.println(
                    "Years: " + period1.getYears() + ", Months: " + period1.getMonths() + ", Days: " + period1.getDays());
        }
    
        public static void parseMethodExample() {
            Period period = Period.parse("P1Y2M3D");
            System.out.println(
                    "Years: " + period.getYears() + ", Months: " + period.getMonths() + ", Days: " + period.getDays());
        }
    
        public static void ofYearsMethodExample() {
            Period period = Period.ofYears(2);
            System.out.println(period.getYears());
        }
    
        public static void ofWeeksMethodExample() {
            Period period = Period.ofWeeks(2);
            System.out.println(period.getDays());
        }
    
        public static void ofMonthsMethodExample() {
            Period period = Period.ofMonths(2);
            System.out.println(period.getMonths());
        }
    
        public static void ofDaysMethodExample() {
            Period period = Period.ofDays(2);
            System.out.println(period.getDays());
        }
    
        public static void ofMethodExample() {
            Period period = Period.of(1, 5, 2);
            System.out.println(
                    "Years: " + period.getYears() + ", Months: " + period.getMonths() + ", Days: " + period.getDays());
        }
    
        public static void minusYearsMethodExample() {
            Period period = Period.ofYears(5);
            System.out.println(period.getYears());
            Period period1 = period.minusYears(3);
            System.out.println(period1.getYears());
        }
    
        public static void minusMonthsMethodExample() {
            Period period = Period.ofMonths(5);
            System.out.println(period.getMonths());
            Period period1 = period.minusMonths(3);
            System.out.println(period1.getMonths());
        }
    
        public static void minusDaysMethodExample() {
            Period period = Period.ofDays(5);
            System.out.println(period.getDays());
            Period period1 = period.minusDays(3);
            System.out.println(period1.getDays());
        }
    }

输出：

Period.ofYears(2)：P2Y
    period.withYears(5)：P5Y
    Period.ofMonths(2)：P2M
    period.withMonths(5)：P5M
    Period.ofDays(2)：P2D
    period.withDays(5)：P5D
    Period.ofYears(2)：24
    2019-08-02T14:53:10.333
    2017-08-02T14:53:10.333
    Period.ofYears(2).plusYears(1)：3
    Period.ofMonths(2).plusMonths(1)：3
    Period.ofDays(2).plusDays(1)：3
    Years: 1, Months: 5, Days: 2
    Years: 1, Months: 5, Days: 7
    Years: 1, Months: 2, Days: 3
    2
    14
    2
    2
    Years: 1, Months: 5, Days: 2
    5
    2
    5
    2
    5
    2

参考资料：

JSR 310 Date and Time API v1.0

[https://docs.oracle.com/javase/tutorial/datetime/overview/index.html][https_docs.oracle.com_javase_tutorial_datetime_overview_index.html]

[https://docs.oracle.com/javase/8/docs/api/java/time/package-summary.html][https_docs.oracle.com_javase_8_docs_api_java_time_package-summary.html]

[https_docs.oracle.com_javase_tutorial_datetime_overview_index.html]: https://docs.oracle.com/javase/tutorial/datetime/overview/index.html
[https_docs.oracle.com_javase_8_docs_api_java_time_package-summary.html]: https://docs.oracle.com/javase/8/docs/api/java/time/package-summary.html