关于challenge:Java-中JDK7时间类与JDK8中的时间类

java.util.Date` 类示意特定的霎时，准确到毫秒。

持续查阅 Date 类的形容，发现 Date 领有多个构造函数，只是局部曾经过期，咱们重点看以下两个构造函数

public Date()：从运行程序的此时此刻到工夫原点经验的毫秒值, 转换成 Date 对象，调配 Date 对象并初始化此对象，以示意调配它的工夫（准确到毫秒）。
public Date(long date)：将指定参数的毫秒值 date, 转换成 Date 对象，调配 Date 对象并初始化此对象，以示意自从规范基准工夫（称为“历元（epoch）”，即 1970 年 1 月 1 日 00:00:00 GMT）以来的指定毫秒数。

tips: 因为中国处于东八区（GMT+08:00）是比世界协调工夫 / 格林尼治工夫（GMT）快 8 小时的时区，当格林尼治规范工夫为 0:00 时，东八区的规范工夫为 08:00。

简略来说：应用无参结构，能够主动设置以后零碎工夫的毫秒时刻；指定 long 类型的结构参数，能够自定义毫秒时刻。例如：

import java.util.Date;

public class Demo01Date {public static void main(String[] args) {
        // 创立日期对象，把以后的工夫
        System.out.println(new Date()); // Tue Jan 16 14:37:35 CST 2020
        // 创立日期对象，把以后的毫秒值转成日期对象
        System.out.println(new Date(0L)); // Thu Jan 01 08:00:00 CST 1970
    }
}

tips: 在应用 println 办法时，会主动调用 Date 类中的 toString 办法。Date 类对 Object 类中的 toString 办法进行了笼罩重写，所以后果为指定格局的字符串。

Date 类中的少数办法曾经过期，罕用的办法有：

public long getTime() 把日期对象转换成对应的工夫毫秒值。
public void setTime(long time) 把办法参数给定的毫秒值设置给日期对象

示例代码

public class DateDemo02 {public static void main(String[] args) {
        // 创立日期对象
        Date d = new Date();
        
        //public long getTime(): 获取的是日期对象从 1970 年 1 月 1 日 00:00:00 到当初的毫秒值
        //System.out.println(d.getTime());
        //System.out.println(d.getTime() * 1.0 / 1000 / 60 / 60 / 24 / 365 + "年");

        //public void setTime(long time): 设置工夫，给的是毫秒值
        //long time = 1000*60*60;
        long time = System.currentTimeMillis();
        d.setTime(time);

        System.out.println(d);
    }
}

小结：Date 示意特定的工夫霎时，咱们能够应用 Date 对象对工夫进行操作。

java.text.SimpleDateFormat 是日期 / 工夫格式化类，咱们通过这个类能够帮咱们实现日期和文本之间的转换, 也就是能够在 Date 对象与 String 对象之间进行来回转换。

格式化：依照指定的格局，把 Date 对象转换为 String 对象。
解析：依照指定的格局，把 String 对象转换为 Date 对象。

因为 DateFormat 为抽象类，不能间接应用，所以须要罕用的子类java.text.SimpleDateFormat。这个类须要一个模式（格局）来指定格式化或解析的规范。构造方法为：

public SimpleDateFormat(String pattern)：用给定的模式和默认语言环境的日期格局符号结构 SimpleDateFormat。参数 pattern 是一个字符串，代表日期工夫的自定义格局。

罕用的格局规定为：

标识字母（辨别大小写）	含意
y	年
M	月
d	日
H	时
m	分
s	秒

备注：更具体的格局规定，能够参考 SimpleDateFormat 类的 API 文档。

DateFormat 类的罕用办法有：

public String format(Date date)：将 Date 对象格式化为字符串。

public Date parse(String source)：将字符串解析为 Date 对象。

package com.itheima.a01jdk7datedemo;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Date;

public class A03_SimpleDateFormatDemo1 {public static void main(String[] args) throws ParseException {
        /*
            public simpleDateFormat() 默认格局
            public simpleDateFormat(String pattern) 指定格局
            public final string format(Date date) 格式化(日期对象 -> 字符串)
            public Date parse(string source) 解析(字符串 -> 日期对象)
        */

        //1. 定义一个字符串示意工夫
        String str = "2023-11-11 11:11:11";
        //2. 利用空参结构创立 simpleDateFormat 对象
        // 细节:
        // 创建对象的格局要跟字符串的格局完全一致
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        Date date = sdf.parse(str);
        //3. 打印后果
        System.out.println(date.getTime());//1699672271000


    }

    private static void method1() {
        //1. 利用空参结构创立 simpleDateFormat 对象，默认格局
        SimpleDateFormat sdf1 = new SimpleDateFormat();
        Date d1 = new Date(0L);
        String str1 = sdf1.format(d1);
        System.out.println(str1);//1970/1/1 上午 8:00

        //2. 利用带参结构创立 simpleDateFormat 对象，指定格局
        SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy 年 MM 月 dd 日 HH:mm:ss");
        String str2 = sdf2.format(d1);
        System.out.println(str2);//1970 年 01 月 01 日 08:00:00

        // 课堂练习:yyyy 年 MM 月 dd 日 时: 分: 秒 星期
    }
}

小结：DateFormat 能够将 Date 对象和字符串互相转换。

/*
     假如，你初恋的出生年月日为:2000-11-11
     请用字符串示意这个数据，并将其转换为:2000 年 11 月 11 日

     创立一个 Date 对象示意 2000 年 11 月 11 日
     创立一个 SimpleDateFormat 对象，并定义格局为年月日把工夫变成:2000 年 11 月 11 日
*/

//1. 能够通过 2000-11-11 进行解析，解析成一个 Date 对象
String str = "2000-11-11";
//2. 解析
SimpleDateFormat sdf1 = new SimpleDateFormat("yyyy-MM-dd");
Date date = sdf1.parse(str);
//3. 格式化
SimpleDateFormat sdf2 = new SimpleDateFormat("yyyy 年 MM 月 dd 日");
String result = sdf2.format(date);
System.out.println(result);

/* 需要:
            秒杀流动开始工夫:2023 年 11 月 11 日 0:0:0(毫秒值)
            秒杀流动完结工夫:2023 年 11 月 11 日 0:10:0(毫秒值)

            小贾下单并付款的工夫为:2023 年 11 月 11 日 0:01:0
            小皮下单并付款的工夫为:2023 年 11 月 11 日 0:11:0
            用代码阐明这两位同学有没有加入上秒杀流动?
         */

//1. 定义字符串示意三个工夫
String startstr = "2023 年 11 月 11 日 0:0:0";
String endstr = "2023 年 11 月 11 日 0:10:0";
String orderstr = "2023 年 11 月 11 日 0:01:00";
//2. 解析下面的三个工夫，失去 Date 对象
SimpleDateFormat sdf = new SimpleDateFormat("yyyy 年 MM 月 dd 日 HH:mm:ss");
Date startDate = sdf.parse(startstr);
Date endDate = sdf.parse(endstr);
Date orderDate = sdf.parse(orderstr);

//3. 失去三个工夫的毫秒值
long startTime = startDate.getTime();
long endTime = endDate.getTime();
long orderTime = orderDate.getTime();

//4. 判断
if (orderTime >= startTime && orderTime <= endTime) {System.out.println("加入秒杀流动胜利");
} else {System.out.println("加入秒杀流动失败");
}

java.util.Calendar 类示意一个“日历类”，能够进行日期运算。它是一个抽象类，不能创建对象，咱们能够应用它的子类：java.util.GregorianCalendar 类。
有两种形式能够获取 GregorianCalendar 对象：
- 间接创立 GregorianCalendar 对象；
- 通过 Calendar 的静态方法 getInstance()办法获取 GregorianCalendar 对象【本次课应用】

办法名	阐明
public static Calendar getInstance()	获取一个它的子类 GregorianCalendar 对象。
public int get(int field)	获取某个字段的值。field 参数示意获取哪个字段的值，能够应用 Calender 中定义的常量来示意： Calendar.YEAR : 年 Calendar.MONTH：月 Calendar.DAY_OF_MONTH：月中的日期 Calendar.HOUR：小时 Calendar.MINUTE：分钟 Calendar.SECOND：秒 Calendar.DAY_OF_WEEK：星期
public void set(int field,int value)	设置某个字段的值
public void add(int field,int amount)	为某个字段减少 / 缩小指定的值

public class Demo {public static void main(String[] args) {
        //1. 获取一个 GregorianCalendar 对象
        Calendar instance = Calendar.getInstance();// 获取子类对象

        //2. 打印子类对象
        System.out.println(instance);

        //3. 获取属性
        int year = instance.get(Calendar.YEAR);
        int month = instance.get(Calendar.MONTH) + 1;//Calendar 的月份值是 0 -11
        int day = instance.get(Calendar.DAY_OF_MONTH);

        int hour = instance.get(Calendar.HOUR);
        int minute = instance.get(Calendar.MINUTE);
        int second = instance.get(Calendar.SECOND);

        int week = instance.get(Calendar.DAY_OF_WEEK);// 返回值范畴：1--7，别离示意："星期日","星期一","星期二",...,"星期六"

        System.out.println(year + "年" + month + "月" + day + "日" + 
                               hour + ":" + minute + ":" + second);
        System.out.println(getWeek(week));

    }

    // 查表法，查问星期几
    public static String getWeek(int w) {//w = 1 --- 7
        // 做一个表(数组)
        String[] weekArray = {"星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"};
        //            索引      [0]      [1]       [2]      [3]       [4]      [5]      [6]
        // 查表
        return weekArray[w - 1];
    }
}

public class Demo {public static void main(String[] args) {// 设置属性——set(int field,int value):
        Calendar c1 = Calendar.getInstance();// 获取以后日期

        // 计算班长出世那天是星期几(如果班长出生日期为：1998 年 3 月 18 日)
        c1.set(Calendar.YEAR, 1998);
        c1.set(Calendar.MONTH, 3 - 1);// 转换为 Calendar 外部的月份值
        c1.set(Calendar.DAY_OF_MONTH, 18);

        int w = c1.get(Calendar.DAY_OF_WEEK);
        System.out.println("班长出世那天是：" + getWeek(w));

        
    }
    // 查表法，查问星期几
    public static String getWeek(int w) {//w = 1 --- 7
        // 做一个表(数组)
        String[] weekArray = {"星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"};
        //            索引      [0]      [1]       [2]      [3]       [4]      [5]      [6]
        // 查表
        return weekArray[w - 1];
    }
}

public class Demo {public static void main(String[] args) {
        // 计算 200 天当前是哪年哪月哪日，星期几？Calendar c2 = Calendar.getInstance();// 获取以后日期
        c2.add(Calendar.DAY_OF_MONTH, 200);// 日期加 200

        int y = c2.get(Calendar.YEAR);
        int m = c2.get(Calendar.MONTH) + 1;// 转换为理论的月份
        int d = c2.get(Calendar.DAY_OF_MONTH);

        int wk = c2.get(Calendar.DAY_OF_WEEK);
        System.out.println("200 天后是：" + y + "年" + m + "月" + d + "日" + getWeek(wk));

    }
    // 查表法，查问星期几
    public static String getWeek(int w) {//w = 1 --- 7
        // 做一个表(数组)
        String[] weekArray = {"星期日", "星期一", "星期二", "星期三", "星期四", "星期五", "星期六"};
        //            索引      [0]      [1]       [2]      [3]       [4]      [5]      [6]
        // 查表
        return weekArray[w - 1];
    }
}

JDK8 工夫类类名	作用
ZoneId	时区
Instant	工夫戳
ZoneDateTime	带时区的工夫
DateTimeFormatter	用于工夫的格式化和解析
LocalDate	年、月、日
LocalTime	时、分、秒
LocalDateTime	年、月、日、时、分、秒
Duration	工夫距离（秒，纳，秒）
Period	工夫距离（年，月，日）
ChronoUnit	工夫距离（所有单位）

/*
        static Set<string> getAvailableZoneIds() 获取 Java 中反对的所有时区
        static ZoneId systemDefault() 获取零碎默认时区
        static Zoneld of(string zoneld) 获取一个指定时区
        */

//1. 获取所有的时区名称
Set<String> zoneIds = ZoneId.getAvailableZoneIds();
System.out.println(zoneIds.size());//600
System.out.println(zoneIds);// Asia/Shanghai

//2. 获取以后零碎的默认时区
ZoneId zoneId = ZoneId.systemDefault();
System.out.println(zoneId);//Asia/Shanghai

//3. 获取指定的时区
ZoneId zoneId1 = ZoneId.of("Asia/Pontianak");
System.out.println(zoneId1);//Asia/Pontianak

/*
            static Instant now() 获取以后工夫的 Instant 对象(规范工夫)
            static Instant ofXxxx(long epochMilli) 依据 (秒 / 毫秒 / 纳秒) 获取 Instant 对象
            ZonedDateTime atZone(ZoneIdzone) 指定时区
            boolean isxxx(Instant otherInstant) 判断系列的办法
            Instant minusXxx(long millisToSubtract) 缩小工夫系列的办法
            Instant plusXxx(long millisToSubtract) 减少工夫系列的办法
        */
//1. 获取以后工夫的 Instant 对象(规范工夫)
Instant now = Instant.now();
System.out.println(now);

//2. 依据 (秒 / 毫秒 / 纳秒) 获取 Instant 对象
Instant instant1 = Instant.ofEpochMilli(0L);
System.out.println(instant1);//1970-01-01T00:00:00z

Instant instant2 = Instant.ofEpochSecond(1L);
System.out.println(instant2);//1970-01-01T00:00:01Z

Instant instant3 = Instant.ofEpochSecond(1L, 1000000000L);
System.out.println(instant3);//1970-01-01T00:00:027

//3. 指定时区
ZonedDateTime time = Instant.now().atZone(ZoneId.of("Asia/Shanghai"));
System.out.println(time);


//4.isXxx 判断
Instant instant4=Instant.ofEpochMilli(0L);
Instant instant5 =Instant.ofEpochMilli(1000L);

//5. 用于工夫的判断
//isBefore: 判断调用者代表的工夫是否在参数示意工夫的后面
boolean result1=instant4.isBefore(instant5);
System.out.println(result1);//true

//isAfter: 判断调用者代表的工夫是否在参数示意工夫的前面
boolean result2 = instant4.isAfter(instant5);
System.out.println(result2);//false

//6.Instant minusXxx(long millisToSubtract) 缩小工夫系列的办法
Instant instant6 =Instant.ofEpochMilli(3000L);
System.out.println(instant6);//1970-01-01T00:00:03Z

Instant instant7 =instant6.minusSeconds(1);
System.out.println(instant7);//1970-01-01T00:00:02Z

/*
            static ZonedDateTime now() 获取以后工夫的 ZonedDateTime 对象
            static ZonedDateTime ofXxxx(。。。) 获取指定工夫的 ZonedDateTime 对象
            ZonedDateTime withXxx(工夫) 批改工夫系列的办法
            ZonedDateTime minusXxx(工夫) 缩小工夫系列的办法
            ZonedDateTime plusXxx(工夫) 减少工夫系列的办法
         */
//1. 获取以后工夫对象(带时区)
ZonedDateTime now = ZonedDateTime.now();
System.out.println(now);

//2. 获取指定的工夫对象(带时区)1/ 年月日时分秒纳秒形式指定
ZonedDateTime time1 = ZonedDateTime.of(2023, 10, 1,
                                       11, 12, 12, 0, ZoneId.of("Asia/Shanghai"));
System.out.println(time1);

// 通过 Instant + 时区的形式指定获取工夫对象
Instant instant = Instant.ofEpochMilli(0L);
ZoneId zoneId = ZoneId.of("Asia/Shanghai");
ZonedDateTime time2 = ZonedDateTime.ofInstant(instant, zoneId);
System.out.println(time2);


//3.withXxx 批改工夫系列的办法
ZonedDateTime time3 = time2.withYear(2000);
System.out.println(time3);

//4. 缩小工夫
ZonedDateTime time4 = time3.minusYears(1);
System.out.println(time4);

//5. 减少工夫
ZonedDateTime time5 = time4.plusYears(1);
System.out.println(time5);

/*
            static DateTimeFormatter ofPattern(格局) 获取格局对象
            String format(工夫对象) 依照指定形式格式化
        */
// 获取工夫对象
ZonedDateTime time = Instant.now().atZone(ZoneId.of("Asia/Shanghai"));

// 解析 / 格式化器
DateTimeFormatter dtf1=DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm;ss EE a");
// 格式化
System.out.println(dtf1.format(time));

//1. 获取以后工夫的日历对象(蕴含 年月日)
LocalDate nowDate = LocalDate.now();
//System.out.println("明天的日期:" + nowDate);
//2. 获取指定的工夫的日历对象
LocalDate ldDate = LocalDate.of(2023, 1, 1);
System.out.println("指定日期:" + ldDate);

System.out.println("=============================");

//3.get 系列办法获取日历中的每一个属性值 // 获取年
int year = ldDate.getYear();
System.out.println("year:" + year);
// 获取月 // 形式一:
Month m = ldDate.getMonth();
System.out.println(m);
System.out.println(m.getValue());

// 形式二:
int month = ldDate.getMonthValue();
System.out.println("month:" + month);


// 获取日
int day = ldDate.getDayOfMonth();
System.out.println("day:" + day);

// 获取一年的第几天
int dayofYear = ldDate.getDayOfYear();
System.out.println("dayOfYear:" + dayofYear);

// 获取星期
DayOfWeek dayOfWeek = ldDate.getDayOfWeek();
System.out.println(dayOfWeek);
System.out.println(dayOfWeek.getValue());

//is 结尾的办法示意判断
System.out.println(ldDate.isBefore(ldDate));
System.out.println(ldDate.isAfter(ldDate));

//with 结尾的办法示意批改，只能批改年月日
LocalDate withLocalDate = ldDate.withYear(2000);
System.out.println(withLocalDate);

//minus 结尾的办法示意缩小，只能缩小年月日
LocalDate minusLocalDate = ldDate.minusYears(1);
System.out.println(minusLocalDate);


//plus 结尾的办法示意减少，只能减少年月日
LocalDate plusLocalDate = ldDate.plusDays(1);
System.out.println(plusLocalDate);

//-------------
// 判断明天是否是你的生日
LocalDate birDate = LocalDate.of(2000, 1, 1);
LocalDate nowDate1 = LocalDate.now();

MonthDay birMd = MonthDay.of(birDate.getMonthValue(), birDate.getDayOfMonth());
MonthDay nowMd = MonthDay.from(nowDate1);

System.out.println("明天是你的生日吗?" + birMd.equals(nowMd));// 明天是你的生日吗?

// 获取本地工夫的日历对象。(蕴含 时分秒)
LocalTime nowTime = LocalTime.now();
System.out.println("明天的工夫:" + nowTime);

int hour = nowTime.getHour();// 时
System.out.println("hour:" + hour);

int minute = nowTime.getMinute();// 分
System.out.println("minute:" + minute);

int second = nowTime.getSecond();// 秒
System.out.println("second:" + second);

int nano = nowTime.getNano();// 纳秒
System.out.println("nano:" + nano);
System.out.println("------------------------------------");
System.out.println(LocalTime.of(8, 20));// 时候
System.out.println(LocalTime.of(8, 20, 30));// 时分秒
System.out.println(LocalTime.of(8, 20, 30, 150));// 时分秒纳秒
LocalTime mTime = LocalTime.of(8, 20, 30, 150);

//is 系列的办法
System.out.println(nowTime.isBefore(mTime));
System.out.println(nowTime.isAfter(mTime));

//with 系列的办法，只能批改时、分、秒
System.out.println(nowTime.withHour(10));

//plus 系列的办法，只能批改时、分、秒
System.out.println(nowTime.plusHours(10));

// 以后工夫的的日历对象(蕴含年月日时分秒)
LocalDateTime nowDateTime = LocalDateTime.now();

System.out.println("明天是:" + nowDateTime);// 明天是：System.out.println(nowDateTime.getYear());// 年
System.out.println(nowDateTime.getMonthValue());// 月
System.out.println(nowDateTime.getDayOfMonth());// 日
System.out.println(nowDateTime.getHour());// 时
System.out.println(nowDateTime.getMinute());// 分
System.out.println(nowDateTime.getSecond());// 秒
System.out.println(nowDateTime.getNano());// 纳秒
// 日: 当年的第几天
System.out.println("dayofYear:" + nowDateTime.getDayOfYear());
// 星期
System.out.println(nowDateTime.getDayOfWeek());
System.out.println(nowDateTime.getDayOfWeek().getValue());
// 月份
System.out.println(nowDateTime.getMonth());
System.out.println(nowDateTime.getMonth().getValue());

LocalDate ld = nowDateTime.toLocalDate();
System.out.println(ld);

LocalTime lt = nowDateTime.toLocalTime();
System.out.println(lt.getHour());
System.out.println(lt.getMinute());
System.out.println(lt.getSecond());

// 本地日期工夫对象。LocalDateTime today = LocalDateTime.now();
System.out.println(today);

// 出世的日期工夫对象
LocalDateTime birthDate = LocalDateTime.of(2000, 1, 1, 0, 0, 0);
System.out.println(birthDate);

Duration duration = Duration.between(birthDate, today);// 第二个参数减第一个参数
System.out.println("相差的工夫距离对象:" + duration);

System.out.println("============================================");
System.out.println(duration.toDays());// 两个时间差的天数
System.out.println(duration.toHours());// 两个时间差的小时数
System.out.println(duration.toMinutes());// 两个时间差的分钟数
System.out.println(duration.toMillis());// 两个时间差的毫秒数
System.out.println(duration.toNanos());// 两个时间差的纳秒数

// 以后本地 年月日
LocalDate today = LocalDate.now();
System.out.println(today);

// 生日的 年月日
LocalDate birthDate = LocalDate.of(2000, 1, 1);
System.out.println(birthDate);

Period period = Period.between(birthDate, today);// 第二个参数减第一个参数

System.out.println("相差的工夫距离对象:" + period);
System.out.println(period.getYears());
System.out.println(period.getMonths());
System.out.println(period.getDays());

System.out.println(period.toTotalMonths());

// 以后工夫
LocalDateTime today = LocalDateTime.now();
System.out.println(today);
// 生日工夫
LocalDateTime birthDate = LocalDateTime.of(2000, 1, 1,0, 0, 0);
System.out.println(birthDate);

System.out.println("相差的年数:" + ChronoUnit.YEARS.between(birthDate, today));
System.out.println("相差的月数:" + ChronoUnit.MONTHS.between(birthDate, today));
System.out.println("相差的周数:" + ChronoUnit.WEEKS.between(birthDate, today));
System.out.println("相差的天数:" + ChronoUnit.DAYS.between(birthDate, today));
System.out.println("相差的时数:" + ChronoUnit.HOURS.between(birthDate, today));
System.out.println("相差的分数:" + ChronoUnit.MINUTES.between(birthDate, today));
System.out.println("相差的秒数:" + ChronoUnit.SECONDS.between(birthDate, today));
System.out.println("相差的毫秒数:" + ChronoUnit.MILLIS.between(birthDate, today));
System.out.println("相差的微秒数:" + ChronoUnit.MICROS.between(birthDate, today));
System.out.println("相差的纳秒数:" + ChronoUnit.NANOS.between(birthDate, today));
System.out.println("相差的半天数:" + ChronoUnit.HALF_DAYS.between(birthDate, today));
System.out.println("相差的十年数:" + ChronoUnit.DECADES.between(birthDate, today));
System.out.println("相差的世纪 (百年) 数:" + ChronoUnit.CENTURIES.between(birthDate, today));
System.out.println("相差的千年数:" + ChronoUnit.MILLENNIA.between(birthDate, today));
System.out.println("相差的纪元数:" + ChronoUnit.ERAS.between(birthDate, today));

本文参加了 SegmentFault 思否面试闯关挑战赛，欢送正在浏览的你也退出。

关于challenge:Java-中JDK7时间类与JDK8中的时间类

第一章 Date 类

1.1 Date 概述

1.2 Date 罕用办法

第二章 SimpleDateFormat 类

2.1 构造方法

2.2 格局规定

2.3 罕用办法

2.4 练习 1(初恋女友的出生日期)

2.5 练习 2(秒杀流动)

第三章 Calendar 类

3.1 概述

3.2 罕用办法

3.3 get 办法示例

3.4 set 办法示例：

3.5 add 办法示例：

第四章 JDK8 工夫相干类

4.1 ZoneId 时区

4.2 Instant 工夫戳

4.3 ZoneDateTime 带时区的工夫

4.4DateTimeFormatter 用于工夫的格式化和解析

4.5LocalDate 年、月、日

4.6 LocalTime 时、分、秒

4.7 LocalDateTime 年、月、日、时、分、秒

4.8 Duration 工夫距离（秒，纳，秒）

4.9 Period 工夫距离（年，月，日）

4.10 ChronoUnit 工夫距离（所有单位）