一.新时间日期API常用、重要对象介绍

• ZoneId: 时区ID，用来确定Instant和LocalDateTime互相转换的规则
• Instant: 用来表示时间线上的一个点（瞬时）
• LocalDate: 表示没有时区的日期, LocalDate是不可变并且线程安全的
• LocalTime: 表示没有时区的时间, LocalTime是不可变并且线程安全的
• LocalDateTime: 表示没有时区的日期时间, LocalDateTime是不可变并且线程安全的
• Clock: 用于访问当前时刻、日期、时间，用到时区
• Duration: 用秒和纳秒表示时间的数量（长短），用于计算两个日期的“时间”间隔
• Period: 用于计算两个“日期”间隔

其中，LocalDate、LocalTime、LocalDateTime是新API里的基础对象，绝大多数操作都是围绕这几个对象来进行的，有必要搞清楚：

LocalDate ： 只含年月日的日期对象
LocalTime ：只含时分秒的时间对象
LocalDateTime： 同时含有年月日时分秒的日期对象

二.API详解与示例

2.1获取当前时间

//获取当前时间
LocalDate localDate = LocalDate.now();  
//结果：2023-11-17

LocalTime localTime = LocalTime.now();  
//结果：09:07:24.614227300

LocalDateTime localDateTime = LocalDateTime.now();  
//结果：2023-11-17T09:07:24.614227300

2.2根据指定日期/时间创建对象

//2.2根据指定日期/时间创建对象
LocalDate localDate = LocalDate.of(2023,11,17);
//结果：2023-11-17

LocalTime localTime = LocalTime.of(12,0,0,20000);
//结果：12:00:00.000020

LocalDateTime localDateTime = LocalDateTime.of(2023,11,17,12,0,0,20000);
//结果：2023-11-17T12:00:00.000020

2.3日期时间的加减

• 对于LocalDate,只有精度大于或等于日的加减，如年、月、日；

• 对于LocalTime,只有精度小于或等于时的加减，如时、分、秒、纳秒；

• 对于LocalDateTime,则可以进行任意精度的时间相加减；

第一种方式：以下方法的参数都是 Long 类型，返回值都是 LocalDateTime

//日期时间的加减（加：加的时间为正整数，减：减的时间为负整数）
LocalDateTime localDateTime = LocalDateTime.of(2023,1,1,1,1,1,1);;

//加年
LocalDateTime plusYearResult = localDateTime.plusYears(2L);
//加月
LocalDateTime plusMonthResult = localDateTime.plusMonths(3L);
//加日
LocalDateTime plusDayResult = localDateTime.plusDays(7L);
//加小时
LocalDateTime plusHourResult = localDateTime.plusHours(12L);
//加分钟
LocalDateTime plusMinuteResult = localDateTime.plusMinutes(10L);
//加秒
LocalDateTime plusSecondResult = localDateTime.plusSeconds(10L);
//加毫秒
LocalDateTime plusNanosResult = localDateTime.plusNanos(20000L);
//加周 = 加7天
LocalDateTime PlusWeekResult = localDateTime.plusWeeks(1L);

第二种方式：也可以为时间相加减日期，即：plus(long amountToAdd, TemporalUnit unit)

参数1：相加减的时间，参数2：相加减的单位

//加年
LocalDateTime plusYearResult2 = localDateTime.plus(2L, ChronoUnit.YEARS);
//加月
LocalDateTime plusMonthResult2 = localDateTime.plus(3L, ChronoUnit.MONTHS);
//加日
LocalDateTime plusDayResult2 = localDateTime.plus(7L, ChronoUnit.DAYS);
//加小时
LocalDateTime plusHourResult2 = localDateTime.plus(12L, ChronoUnit.HOURS);
//加分钟
LocalDateTime plusMinuteResult2 = localDateTime.plus(10L, ChronoUnit.MINUTES);
//加秒
LocalDateTime plusSecondResult2 = localDateTime.plus(10L, ChronoUnit.SECONDS);
//加毫秒
LocalDateTime plusNanosResult2 = localDateTime.plus(20000L, ChronoUnit.NANOS);
//加周 = 加7天
LocalDateTime PlusWeekResult2 = localDateTime.plus(1L, ChronoUnit.WEEKS);

2.4将年、月、日等修改为指定的值，并返回新的日期（时间）对象

其效果与时间日期相加减差不多，如今天是2018-01-13，要想变为2018-01-20有两种方式
a. localDate.plusDays(20L) -> 相加指定的天数
b. localDate.withDayOfYear(20) -> 直接指定到哪一天

LocalDate localDate = LocalDate.now();
//当前时间基础上，指定本年当中的第几天，取值范围为1-365,366
LocalDate withDayOfYearResult = localDate.withDayOfYear( 200);
// 当前时间基础上，指定本月当中的第几天，取值范围为1-29,30,31
LocalDate withDayOfMonthResult = localDate.withDayOfMonth(5);
// 当前时间基础上，直接指定年份
LocalDate withYearResult = localDate.withYear(2017);
//当前时间基础上，直接指定月份
LocalDate withMonthResult = localDate.withMonth(5);

2.5获取日期的年月日周时分秒

LocalDateTime localDateTime = LocalDateTime.now();
//获取本年中的第多少天
int dayOfYear = localDateTime.getDayOfYear();
//获取本月中的第多少天
int dayOfMonth = localDateTime.getDayOfMonth();
//获取本周中的星期几
DayOfWeek dayofweek = localDateTime.getDayOfWeek();
System.out.println(
    "今天是"+ localDateTime + "\n" +
    "本年当中第：" + dayOfYear + "天" + "\n" +
    "本月当中第：" + dayOfMonth + "天" + "\n" +
    "星期几：" + dayofweek.getValue() + "\n" +
    "-即" + dayofweek
);
//获取当天时间的年月日时分秒
//获取日期时间中的年
int year = localDateTime .getYear();
//获取日期时间中的月
Month month = localDateTime.getMonth();
//获取日期时间中的日
int day = localDateTime.getDayOfMonth();
//获取日期时间中的小时
int hour = localDateTime.getHour();
//获取日期时间中的分钟
int minute = localDateTime.getMinute();
//获取日期时间中的秒
int second = localDateTime.getSecond();
//获取日期时间中的年毫秒
long nano = localDateTime.getNano();
//获取日期时间中的星期几
DayOfWeek dayofweek2 = localDateTime.getDayOfWeek();
System.out.println(
    "今天是：" + localDateTime + "\n"
    + "年：" + year + "\n"
    + "月：" + month.getValue() + "\n"
    + "日：" + day + "\n"
    + "时：" + hour + "\n"
    + "分：" + minute + "\n"
    + "秒：" + second + "\n"
    + "毫秒：" + nano + "\n"
    + "星期：" + dayofweek2.getValue() + "-即星期：" + dayofweek
);

2.6时间日期前后的比较与判断

//时间日期前后的比较与判断
LocalDate localDate1 = LocalDate.of(2023,11,17);
LocalDate localDate2 = LocalDate.of(2023,10,11);
if (localDate1.isBefore(localDate2)) {
    
    System.out.println("localDateTime1在localDateTime2之前");
}else{
    
    System.out.println("localDateTime1在localDateTime2之后");
}

2.7时间戳

事实上Instant就是java8以前的Date，可以使用以下两个类中的方法在这两个类型之间进行转换，
比如Date.from(Instant)就是用来把Instant转换成java.util.date的，而new Date().toInstant()就是将Date转换成Instant的

Instant instant = Instant.now();
//instant 结果：2023-11-17T02:34:22.879094300Z
System.out.println(instant);
Date date = Date.from(instant);
//date 结果：Fri Nov 17 10:34:22 CST 2023
Instant instant2 = date.toInstant();
//instant2 结果：2023-11-17T02:34:22.879Z
System.out.println(date + "\n" +instant2);

2.8计算时间、日期间隔

Duration:用于计算两个“日期”间隔

​ 语法：Period.between(日期1, 日期2)

//计算两个日期的日期间隔-年月日
LocalDate date1 = LocalDate.of(2018, 2, 13);
LocalDate date2 = LocalDate.of(2017, 3, 12);
//内部是用date2-date1，所以得到的结果是负数
Period period = Period.between(date1, date2);
System.out.println("相差年数 ： " + period.getYears());
System.out.println("相差月数 ： " + period.getMonths());
System.out.println("相差日数 ： " + period.getDays());
//还可以这样获取相差的年月日
System.out.println("-------------------------------");
long years = period.get(ChronoUnit.YEARS);
long months = period.get(ChronoUnit.MONTHS);
long days = period.get(ChronoUnit.DAYS);
System.out.println("相差的年月日分别为 ： " + years + "," + months + "," + days);
//注意，当获取两个日期的间隔时，并不是单纯的年月日对应的数字相加减，而是会先算出具体差多少天，在折算成相差几年几月几日的

Period:用于计算两个“时间”间隔

​ 语法：Duration.between(时间1,时间2)

//计算两个时间的间隔
System.out.println("-------------------------------");
LocalDateTime date3 = LocalDateTime.now();
LocalDateTime date4 = LocalDateTime.of(2018, 1, 13, 22, 30, 10);
Duration duration = Duration.between(date3, date4);
System.out.println(
    date3 + " 与 " + date4 + " 间隔  " + "\n"
    + " 天 :" + duration.toDays() + "\n"
    + " 时 :" + duration.toHours() + "\n"
    + " 分 :" + duration.toMinutes() + "\n"
    + " 毫秒 :" + duration.toMillis() + "\n"
    + " 纳秒 :" + duration.toNanos() + "\n"
);
//注意，并没有获得秒差的，但既然可以获得毫秒，秒就可以自行获取了

2.10使用自定义格式自定义转化的格式一定要与日期类型对应

• LocalDate只能设置仅含年月日的格式

LocalDateTime date2 = LocalDateTime.now();
DateTimeFormatter formatter2 = DateTimeFormatter.ofPattern("yyyy年MM月dd日");
String dateStr2 = formatter2.format(date2);
System.out.println(dateStr2);

• LocalTime只能设置仅含时分秒的格式

LocalDateTime date = LocalDateTime.now();
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("HH小时mm分钟ss秒");
String dateStr = formatter.format(date);
System.out.println(dateStr);

• LocalDateTime可以设置含年月日时分秒的格式

LocalDateTime date1 = LocalDateTime.now();
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss");
String dateStr3 = formatter.format(date1);
System.out.println(dateStr3);

2.11将时间字符串形式转化为日期对象

注：格式的写法必须与字符串的形式一样
2018-01-13 21:27:30 对应 yyyy-MM-dd HH:mm:ss
20180113213328 对应 yyyyMMddHHmmss 否则会报运行时异常！

但要记住：得到的最终结果都是类似2018-01-13T21:27:30的格式，因为在输出LocalDateTime对象时，会调用其重写的toString方法。

String datetime = "2023-11-11 11:11:11";
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
LocalDateTime localDateTime = LocalDateTime.parse(datetime,formatter);
System.out.println(localDateTime);

2.12将时间日期对象转为格式化后的时间日期对象

新的格式化API中，格式化后的结果都默认是 String 字符串类型，有时我们也需要返回经过格式化的同类型对象

LocalDateTime localDateTime = LocalDateTime.now();
DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss");
String dateStr = formatter.format(localDateTime);
LocalDateTime localDateTime2 = LocalDateTime.parse(dateStr, formatter);
System.out.println(localDateTime2);

2.13时间戳(long毫秒值)转换为日期

时间 转 时间戳

时间转时间戳分为两种，一种是当你已经有一个LocalDateTime类型的时间了，需要转换成秒或者毫秒的时间戳。

时间转换秒级时间戳

只需要直接用toEpochSecond方法就可以了。

LocalDateTime time = LocalDateTime.now();
time.toEpochSecond(ZoneOffset.ofHours(8));
//毫秒级
long l2 = time.toInstant(ZoneOffset.ofHours(8)).toEpochMilli();
//秒级
long l3 = time.toInstant(ZoneOffset.ofHours(8)).getEpochSecond();

Date类型没有办法直接time秒级时间戳，只能获取毫秒级再转秒。

时间转换毫秒级时间戳

转换毫秒需要先转换成instant对象，然后才能转换成毫秒级时间戳。

LocalDateTime time = LocalDateTime.now();
time.toInstant(ZoneOffset.ofHours(8)).toEpochMilli();

Date获取毫秒就很简单了。

Date date = new Date();
date.getTime();

字符串 转换 时间戳

时间转时间戳分为两种，除了上面的，还有一种是有一个格式化好的字符串，比如2022-12-18 10:00:00这种，但是这个是字符串并不是时间类型。所以要先转换成LocalDateTime类型，然后就可以转换成时间戳了。

其实就是上面格式化的一种反向操作。使用parse方法就可以了。

LocalDateTime.parse("2022-12-18 10:00:00", DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
LocalDateTime.parse("2022-12-18", DateTimeFormatter.ofPattern("yyyy-MM-dd"));	

Date类型的字符串转时间戳也是通过SimpleDateFormat类来完成。

SimpleDateFormat format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
Date date = format.parse("2022-12-18 10:00:00")

时间戳 转 时间

那如果我们现在转换成时间戳以后又想转换成时间呢？也可以通过instant对象来做到。

毫秒时间戳转时间

Instant.ofEpochSecond(1671365543834)是将一个毫秒时间戳转换成一个instant对象。在通过ofInstant方法就可以将instant对象转换成LocalDateTime对象了。

LocalDateTime.ofInstant(Instant.ofEpochSecond(1671365543834), ZoneOffset.ofHours(8));

Date类

Date date = new Date(1669759566000L);

秒时间戳转时间

Instant.ofEpochMilli(1671365543)是将一个秒时间戳转换成instant对象。和上面的区别就是使用的是ofEpochMilli方法。

LocalDateTime.ofInstant(Instant.ofEpochMilli(1671365543), ZoneOffset.ofHours(8));

Date类不支持秒，只能把秒转成毫秒在转时间戳。