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

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/8/docs/api/java/time/package-summary.html

最后

以上就是含蓄秋天为你收集整理的Java 8（七）：新的Date 和 Time API的全部内容，希望文章能够帮你解决Java 8（七）：新的Date 和 Time API所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。