Java8之日期和时间demo

        /*
         * @description: Java 8之前老版的java.util.Date类以及其他用于建模日期时间的类有很多不一致及
         * 设计上的缺陷，包括易变性以及糟糕的偏移值、默认值和命名。  新版的日期和时间API中，日期时间对象是不可变的。 
         * 新的API提供了两种不同的时间表示方式，有效地区分了运行时人和机器的不同需求。 
         * 你可以用绝对或者相对的方式操纵日期和时间，操作的结果总是返回一个新的实例，老 的日期时间对象不会发生变化。 
         * TemporalAdjuster让你能够用更精细的方式操纵日期，不再局限于一次只能改变它的 一个值，并且你还可按照需求定义自己的日期转换器。 
         * 你现在可以按照特定的格式需求，定义自己的格式器，打印输出或者解析日期时间对象。 这些格式器可以通过模板创建，也可以自己编程创建，并且它们都是线程安全的。
         *  你可以用相对于某个地区/位置的方式，或者以与UTC/格林尼治时间的绝对偏差的方式表 示时区，并将其应用到日期时间对象上，对其进行本地化。 
         * 你现在可以使用不同于ISO-8601标准系统的其他日历系统了。
         */

        
        // 日期时间类中表示时间间隔的通用方法
        // 方法名                                             是否是静态方法                                         方法描述
        // between            是                                                                  创建两个时间点之间的interval
        // from               是                                                                  由一个临时时间点创建interval
        // of                 是                                                                  由它的组成部分创建interval 的实例
        // parse              是                                                                  由字符串创建interval 的实例
        // addTo              否                                                                  创建该interval的副本，并将其叠加到某个指定的temporal 对象
        // get                否                                                                  读取该interval的状态
        // isNegative         否                                                                  检查该interval是否为负值，不包含零
        // isZero             否                                                                  检查该interval的时长是否为零
        // minus              否                                                                  通过减去一定的时间创建该interval 的副本
        // multipliedBy       否                                                                  将interval 的值乘以某个标量创建该interval 的副本
        // negated            否                                                                  以忽略某个时长的方式创建该interval 的副本
        // plus               否                                                                  以增加某个指定的时长的方式创建该interval的副本
        // subtractFrom       否                                                                  从指定的temporal 对象中减去该interval
        
        //表示时间点的日期时间类的通用方法
        // 方 法 名          是否是静态方法            描 述
        // from    是                                    依据传入的Temporal 对象创建对象实例
        // now     是                                    依据系统时钟创建Temporal 对象
        // of      是                                    由Temporal 对象的某个部分创建该对象的实例
        // parse   是                                    由字符串创建Temporal 对象的实例
        // atOffset否                                    将Temporal 对象和某个时区偏移相结合
        // atZone  否                                    将Temporal 对象和某个时区相结合
        // format  否                                   使用某个指定的格式器将Temporal 对象转换为字符串（Instant 类不提供该方法）
        // get     否                                   读取Temporal 对象的某一部分的值
        // minus   否                                   创建Temporal 对象的一个副本，通过将当前Temporal 对象的值减去一定的时长创建该副本
        // plus    否                                   创建Temporal 对象的一个副本，通过将当前Temporal 对象的值加上一定的时长创建该副本
        // with    否                                   以该Temporal 对象为模板，对某些状态进行修改创建该对象的副本
        // 1、使用LocalDate
        // 1.1、创建一个LocalDate对象并读取其值
        LocalDate date = LocalDate.of(2020, 2, 8);
        // 获取当前时间
        LocalDate nowDate = LocalDate.now();
        // 年：2020
        int year = date.getYear();
        // 月份：FEBRUARY
        Month month = date.getMonth();
        // 月份值：2
        int monthValue = date.getMonthValue();
        // 日：8
        int day = date.getDayOfMonth();
        // 周几：SATURDAY
        DayOfWeek dow = date.getDayOfWeek();
        // 月长：29
        int len = date.lengthOfMonth();
        // 是否闰年：true：闰年，false：平年
        boolean leap = date.isLeapYear();

        // 1.2、使用TemporalField读取LocalDate的值
        year = date.get(ChronoField.YEAR);
        monthValue = date.get(ChronoField.MONTH_OF_YEAR);
        day = date.get(ChronoField.DAY_OF_MONTH);

        // 1.3、解析字符串创建对象如：2020-02-08
        date = LocalDate.parse("2020-02-08");
        year = date.get(ChronoField.YEAR);
        monthValue = date.get(ChronoField.MONTH_OF_YEAR);
        day = date.get(ChronoField.DAY_OF_MONTH);

        // 1.4、解析日期字符串如：2020:02:08，yyyy:MM:dd
        date = LocalDate.parse("2020:02:08", DateTimeFormatter.ofPattern("yyyy:MM:dd"));
        year = date.get(ChronoField.YEAR);
        monthValue = date.get(ChronoField.MONTH_OF_YEAR);
        day = date.get(ChronoField.DAY_OF_MONTH);

        // 2、使用LocalTime
        // 2.1、创建一个LocalTime对象并读取其值
        LocalTime time = LocalTime.of(13, 45, 20);
        LocalTime nowTime = LocalTime.now();

        int hour = time.getHour();
        int minute = time.getMinute();
        int second = time.getSecond();

        // 2.2、使用TemporalField读取LocalTime的值
        hour = time.get(ChronoField.HOUR_OF_DAY);
        minute = time.get(ChronoField.MINUTE_OF_HOUR);
        second = time.get(ChronoField.SECOND_OF_MINUTE);

        // 2.3、解析字符串创建对象如：12:13:14
        time = LocalTime.parse("12:13:14");
        hour = time.get(ChronoField.HOUR_OF_DAY);
        minute = time.get(ChronoField.MINUTE_OF_HOUR);
        second = time.get(ChronoField.SECOND_OF_MINUTE);

        // 2.4、解析字符串创建对象如：12-13-14，HH-mm-ss
        time = LocalTime.parse("12-13-14", DateTimeFormatter.ofPattern("HH-mm-ss"));
        hour = time.get(ChronoField.HOUR_OF_DAY);
        minute = time.get(ChronoField.MINUTE_OF_HOUR);
        second = time.get(ChronoField.SECOND_OF_MINUTE);

        // 3、使用LocalDateTime
        // 3.1、构造LocalDateTime
        LocalDateTime dt1 = LocalDateTime.of(2020, Month.MARCH, 8, 13, 45, 20);
        LocalDateTime dt2 = LocalDateTime.of(date, time);
        LocalDateTime dt3 = date.atTime(13, 45, 20);
        LocalDateTime dt4 = date.atTime(time);
        LocalDateTime dt5 = time.atDate(date);

        // 3.2、从LocalDateTime中提取LocalDate或者LocalTime
        date = dt1.toLocalDate();
        time = dt1.toLocalTime();

        // 4、Instant机器的日期和时间格式
        // 4.1、构造Instant
        Instant instant = Instant.ofEpochSecond(3);
        Instant.now();

        /* 5、Duration */
        Duration duration = Duration.between(dt1, dt2);

        /* 6、Period 以年、月或者日的方式对多个时间单位建 */
        Period period = Period.between(LocalDate.of(2014, 3, 8), LocalDate.of(2014, 3, 18));

        /* 7、TemporalAdjusters操作时间 */
        // dayOfWeekInMonth 创建一个新的日期，它的值为同一个月中每一周的第几天
        // firstDayOfMonth 创建一个新的日期，它的值为当月的第一天
        // firstDayOfNextMonth 创建一个新的日期，它的值为下月的第一天
        // firstDayOfNextYear 创建一个新的日期，它的值为明年的第一天
        // firstDayOfYear 创建一个新的日期，它的值为当年的第一天
        // firstInMonth 创建一个新的日期，它的值为同一个月中，第一个符合星期几要求的值
        // lastDayOfMonth 创建一个新的日期，它的值为当月的最后一天
        // lastDayOfNextMonth 创建一个新的日期，它的值为下月的最后一天
        // lastDayOfNextYear 创建一个新的日期，它的值为明年的最后一天
        // lastDayOfYear 创建一个新的日期，它的值为今年的最后一天
        // lastInMonth 创建一个新的日期，它的值为同一个月中，最后一个符合星期几要求的值
        // next/previous 创建一个新的日期，并将其值设定为日期调整后或者调整前，第一个符合指定星 期几要求的日期
        // nextOrSame/previousOrSame
        // 创建一个新的日期，并将其值设定为日期调整后或者调整前，第一个符合指定星期几要求的日期，如果该日期已经符合要求，直接返回该对象
        System.out.println(LocalDate.now().with(TemporalAdjusters.dayOfWeekInMonth(2, DayOfWeek.SATURDAY)).getDayOfMonth());
        
        date = LocalDate.of(2020, 2, 7);
        
        date = date.with(temporal -> {
            DayOfWeek d = DayOfWeek.of(temporal.get(ChronoField.DAY_OF_WEEK));
            int dayToAdd = 1;
            if (d == DayOfWeek.FRIDAY)
                dayToAdd = 3;
            else if (d == DayOfWeek.SATURDAY)
                dayToAdd = 2;
            return temporal.plus(dayToAdd, ChronoUnit.DAYS);
        });
        
        TemporalAdjuster nextWorkingDay = TemporalAdjusters.ofDateAdjuster(temporal -> {
            DayOfWeek d = DayOfWeek.of(temporal.get(ChronoField.DAY_OF_WEEK));
            int dayToAdd = 1;
            if (d == DayOfWeek.FRIDAY)
                dayToAdd = 3;
            if (d == DayOfWeek.SATURDAY)
                dayToAdd = 2;
            return temporal.plus(dayToAdd, ChronoUnit.DAYS);
        });
        date = date.with(nextWorkingDay);
        
        System.out.println(date.getDayOfMonth());

        /* 8、format */
        String s = date.format(DateTimeFormatter.BASIC_ISO_DATE);

        /*
         * 9、ISO-8601日历系统是世界文明日历系统的事实标准。但是，Java 8中另外还提供了4种其他的
         * 日历系统。这些日历系统中的每一个都有一个对应的日志类，分别是ThaiBuddhistDate、 MinguoDate 、JapaneseDate
         * 以及HijrahDate 。所有这些类以及LocalDate 都实现了
         * ChronoLocalDate接口，能够对公历的日期进行建模。利用LocalDate对象，你可以创建这些
         * 类的实例。更通用地说，使用它们提供的静态工厂方法，你可以创建任何一个Temporal对象的实例
         */
        date = LocalDate.of(2014, Month.MARCH, 18);
        JapaneseDate japaneseDate = JapaneseDate.from(date);