java8的时间增强类分类详解

java8的时间增强类分类详解

本文大纲
一、时间日期类
二、年月日
三、时区
四、时间段
五、日期格式化
六、时间调整
七、时钟

Java 8 Date Time API包

java.time包：这是新的Java Date Time API的基础包。所有主要的基类是该计划的一部分，比如LocalDate，LocalTime，LocalDateTime，Instant，Period，Duration等所有这些类是不可变的和线程安全的。大多数情况下，这些类足以满足常见要求。

java.time.chrono包：此包定义非ISO日历系统的通用API。我们可以扩展AbstractChronology类来创建我们自己的日历系统。

java.time.format包：此包包含用于格式化和解析日期时间对象的类。大多数情况下，我们不会直接使用它们，因为java.time包中的主要类提供了格式化和解析方法。

java.time.temporal包：此包包含临时对象，我们可以使用它来查找与日期/时间对象相关的特定日期或时间。例如，我们可以使用这些来查找该月的第一天或最后一天。您可以轻松识别这些方法，因为它们始终具有“withXXX”格式。

java.time.zone包：此包包含用于支持不同时区及其规则的类。

方法前缀的含义,统一了api

of：静态工厂方法(用类名去调用)。
parse：静态工厂方法，关注于解析(用类名去调用)。
now： 静态工厂方法，用当前时间创建实例(用类名去调用)
get：获取某些东西的值。
is：检查某些东西的是否是true。
with：返回一个部分状态改变了的时间日期对象拷贝(单独一个with方法,参数为TemporalAdjusters类型)。
plus：返回一个时间增加了的、时间日期对象拷贝(如果参数是负数也能够有minus方法的效果)。
minus：返回一个时间减少了的、时间日期对象拷贝。
to：把当前时间日期对象转换成另外一个，可能会损失部分状态。
at：把这个对象与另一个对象组合起来，例如： date.atTime(time)。
format :根据某一个DateTimeFormatter格式化为字符串。

一、时间日期类

LocalDate 不可变的类，该类代表不带时区的日期，如：2019-02-24
LocalTime 不可变的类，该类代表不带时区的时间，如：10:20:09
LocalDateTime 不可变的类，该类代表不带时区的日期、时间，如：2019-02-24T10:20:09

1.1、LocalDate（年月日）详解

序号	方法	描述
1	now	根据当前时间创建LocalDate对象
2	of	根据指定年月日创建LocalDate对象
3	getYear	获得年份
4	getMonthValue	获得月份
5	getMonth	获得月份枚举值
6	getDayOfMonth	获得月份天数（1-31）
7	getDayOfWeek	获得星期几
8	getDayOfYear	获得年份中的第几天（1-366）
9	lengthOfYear	获得当年总天数
10	lengthOfMonth	获得当月总天数
11	toEpochDay	与时间纪元（1970年1月1日）相差的天数
12	plusDays	加天
13	plusWeeks	加周
14	plusMonths	加月
15	plusYears	加年
16	minusDays	减年
17	minusWeeks	减周
18	minusMonths	减月
19	minusYears	减年
20	withYear	替换年份
21	withYear	替换年份
22	withDayOfMonth	替换日期
23	withDayOfYear	替换日期
24	isBefore	是否日期在之前
25	isAfter	是否日期在之后
26	isEqual	是否是当前日期
27	isleapYear	是否是闰年

(1)获取

//（1）获取当前日期 2022-07-07
System.out.println(LocalDate.now());

//（2）获取指定日期 2000-03-05
System.out.println(LocalDate.of(2014, 3, 5));

//（3）获取日期的年份 2022
System.out.println(LocalDate.now().getYear());

//（4）获取日期的月份 7
System.out.println(LocalDate.now().getMonthValue());

//（5）获取日期的日子 7
System.out.println(LocalDate.now().getDayOfMonth());

//（6）获取日期的星期 THURSDAY
System.out.println(LocalDate.now().getDayOfWeek());

//（7）当天所在这一年的第几天 188
System.out.println(LocalDate.now().getDayOfYear());

//（8）获取当年天数 365
System.out.println(LocalDate.now().lengthOfYear());

//（9）获取当月天数 31
System.out.println(LocalDate.now().lengthOfMonth());

//（10）与时间纪元（1970年1月1日）相差的天数，负数表示在时间纪元之前多少天 19180
System.out.println(LocalDate.now().toEpochDay());

(2)运算

//（1）加一天
System.out.println("加1天：" + LocalDate.now().plusDays(1));

//（2）加一周
System.out.println("加1周：" + LocalDate.now().plusWeeks(1));

//（3）加一月
System.out.println("加1月：" + LocalDate.now().plusMonths(1));

//（4）加一年
System.out.println("加1年：" + LocalDate.now().plusYears(1));

//（5）减一天
System.out.println("减1天：" + LocalDate.now().minusDays(1));

//（6）减一周
System.out.println("减1周：" + LocalDate.now().minusWeeks(1));

//（7）减一月
System.out.println("减1月：" + LocalDate.now().minusMonths(1));

//（8）减一年
System.out.println("减1年：" + LocalDate.now().minusYears(1));

(3)替换

//（1）替换年份：2000-07-07
System.out.println("替换年份为2000：" + LocalDate.now().withYear(2000));

//（2）替换月份：2020-01-07
System.out.println("替换月份为1：" + LocalDate.now().withMonth(1));

//（3）替换日子：2020-07-01
System.out.println("替换日期为1：" + LocalDate.now().withDayOfMonth(1));

//（4）替换天数：一年中的第多少天
System.out.println("替换天数为1：" + LocalDate.now().withDayOfYear(1));

(4)比较

//（1）是否在当天之前
System.out.println("是否在当天之前：" + LocalDate.now().minusDays(1).isBefore(LocalDate.now()));

//（2）是否在当天之后
System.out.println("是否在当天之后：" + LocalDate.now().plusDays(1).isAfter(LocalDate.now()));

//（3）是否在当天
System.out.println("是否在当天：" + LocalDate.now().isEqual(LocalDate.now()));

//（4）是否是闰年
System.out.println("今年是否是闰年：" + LocalDate.now().isLeapYear());

(5)LocalDate 与 String 之间的转换

//（1）从文本字符串获取LocalDate实例
LocalDate localdate = LocalDate.parse("2022-04-21");

System.out.println(localdate);

//（2）使用特定格式化形式从文本字符串获取LocalDate实例
String str = "2019-03-03";

DateTimeFormatter fmt1 = DateTimeFormatter.ofPattern("yyyy-MM-dd");

LocalDate date = LocalDate.parse(str, fmt1);

System.out.println(date);

//（3）使用特定格式化形式将LocalDate转为字符串
LocalDate today = LocalDate.now();

DateTimeFormatter fmt = DateTimeFormatter.ofPattern("yyyy/MM/dd");

String dateStr = today.format(fmt);

System.out.println(dateStr);

(6)LocalDate 与 Date之间的转换

//（1）LocalDate转化为Date
ZonedDateTime zonedDateTime = LocalDate.now().atStartOfDay(ZoneId.systemDefault());

Date date = Date.from(zonedDateTime.toInstant());

System.out.println(new SimpleDateFormat("yyyy-MM-dd").format(date));

//（2）Date转化为LocalDate
LocalDate localDate = new Date().toInstant().atZone(ZoneId.systemDefault()).toLocalDate();

System.out.println(localDate.format(DateTimeFormatter.ISO_LOCAL_DATE));

1.2、LocalTime（时分秒）详解

序号	方法	描述
1	static LocalTime now()	获取默认时区的当前时间
2	static LocalTime now(ZoneId zone)	获取指定时区的当前时间
3	static LocalTime now(Clock clock)	从指定时钟获取当前时间
4	of	根据指定的时、分、秒获取LocalTime 实例
5	getHour	获取小时字段
6	getMinute	获取分钟字段
7	getSecond	获取秒字段
8	getNano	获取纳秒字段
9	plusHours	增加小时数
11	plusMinutes	增加分钟数
11	plusSeconds	增加秒数
12	plusNanos	增加纳秒数
13	minusHours	减少小时数
14	minusMinutes	减少分钟数
15	minusSeconds	减少秒数
16	minusNanos	减少纳秒数
17	compareTo	时间与另一个时间比较
18	isAfter	检查时间是否在指定时间之后
19	isBefore	检查时间是否在指定时间之前

(1)获取

//（1）获取默认时区的当前时间 14:11:31.294
System.out.println(LocalTime.now());

//（2）获取指定时区的当前时间 14:11:31.392
System.out.println(LocalTime.now(ZoneId.of("Asia/Shanghai")));

//（3）从指定时钟获取当前时间 14:11:31.392
System.out.println(LocalTime.now(Clock.systemDefaultZone()));

//（4）指定获取时分秒
System.out.println(LocalTime.of(12, 30, 30));

//（5）指定获取时分
System.out.println(LocalTime.of(12, 30));

//（6）指定获取时分秒纳秒
System.out.println(LocalTime.of(12, 30, 30, 123));

//（7）获取小时字段
System.out.println("时: " + LocalTime.now().getHour());

//（8）获取分钟字段
System.out.println("分: " + LocalTime.now().getMinute());

//（9）获取秒字段
System.out.println("秒: " + LocalTime.now().getSecond());

//（10）获取纳秒字段
System.out.println("纳秒: " + LocalTime.now().getNano());

(2)计算

//（1）增加一小时
System.out.println("增加1小时: " + LocalTime.now().plusHours(1));

//（2）增加三十分钟
System.out.println("增加30分钟: " + LocalTime.now().plusMinutes(30));

//（3）增加三十秒
System.out.println("增加30秒: " + LocalTime.now().plusSeconds(30));

//（4）增加一万纳秒
System.out.println("增加10000纳秒:" + LocalTime.now().plusNanos(10000));

//（5）减少一小时
System.out.println("减少1小时: " + LocalTime.now().minusHours(1));

//（6）减少三十分钟
System.out.println("减少30分钟: " + LocalTime.now().minusMinutes(30));

//（7）减少三十秒
System.out.println("减少30秒: " + LocalTime.now().minusSeconds(30));

//（8）减少一万纳秒
System.out.println("减少10000纳秒:" + LocalTime.now().minusNanos(10000));

(3)比较

//（1）时间与另一个时间比较 0（相等）正数（大）负数（小）
System.out.println(LocalTime.now().compareTo(LocalTime.now()));

//（2）检查时间是否在指定时间之后
System.out.println(LocalTime.now().isAfter(LocalTime.now()));

//（3）检查时间是否在指定时间之前
System.out.println(LocalTime.now().isBefore(LocalTime.now()));

1.3、LocalDateTime（年月日时分秒）详解

序号	方法	描述
1	static LocalDateTime now()	获取默认时区的当前日期时间
2	static LocalDateTime now(Clock clock)	从指定时钟获取当前日期时间
3	static LocalDateTime now(ZoneId zone)	获取指定时区的当前日期时间
4	static LocalDateTime of(LocalDate date, LocalTime time)	根据日期和时间对象获取LocalDateTime 实例
5	static LocalDateTime of(int year, Month month, int dayOfMonth, int hour, int minute, int second)	根据指定的年、月、日、时、分、秒获取LocalDateTime 实例
6	getYear	获取年份
7	getMonth	使用月份枚举类获取月份
8	getDayOfMonth	获取日期在该月是第几天
9	getDayOfWeek	获取日期是星期几
10	getDayOfYear	获取日期在该年是第几天
11	getHour	获取小时
12	getMinute	获取分钟
13	getSecond	获取秒
14	getNano	获取纳秒
15	plusYears	增加年
16	plusMonths	增加月
17	plusWeeks	增加周
18	plusDays	增加天
19	plusHours	增加小时
20	plusMinutes	增加分
21	plusSeconds	增加秒
22	plusNanos	增加纳秒
23	minusYears	减少年
24	minusMonths	减少月
25	meminusWeeks	减少周
26	minusDays	减少天
27	minusHours	减少小时
28	minusMinutes	减少分
29	minusSeconds	减少秒
30	minusNanos	减少纳秒
31	isEqual	判断日期时间是否相等
32	isBefore	检查是否在指定日期时间之前
33	isAfter	检查是否在指定日期时间之后

(1)获取

//（1）获取默认时区的当前日期时间
System.out.println(LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));

//（2）获取指定时区的当前日期时间
System.out.println(LocalDateTime.now(ZoneId.of("Asia/Shanghai")));

//（3）从指定时钟获取当前日期时间
System.out.println(LocalDateTime.now(Clock.systemDefaultZone()));

//（4）根据日期和时间对象获取LocalDateTime实例
System.out.println(LocalDateTime.of(LocalDate.now(), LocalTime.now()));

//（5）根据指定的年、月、日、时、分、秒获取LocalDateTime实例
System.out.println(LocalDateTime.of(2019, 12, 7, 21, 48, 50));

//（6）获取年份
System.out.println("年 : " + LocalDateTime.now().getYear());

//（7）使用月份枚举类获取月份
System.out.println("月（英文） : " + LocalDateTime.now().getMonth());

//（8) 使用月份数字类获取月份
System.out.println(" 月（数字英文）: " + LocalDateTime.now().getMonth().getValue());

//（9）获取日期在该月是第几天
System.out.println("天 : " + LocalDateTime.now().getDayOfMonth());

//（10）获取日期是星期几（英文）
System.out.println("星期几（英文） : " + LocalDateTime.now().getDayOfWeek());

//（11）获取日期是星期几（数字英文）
System.out.println("星期几（数字英文） : " + LocalDateTime.now().getDayOfWeek().getValue());

//（12）获取日期在该年是第几天
System.out.println("本年的第几天 : " + LocalDateTime.now().getDayOfYear());

//（13）获取小时
System.out.println("时: " + LocalDateTime.now().getHour());

//（14）获取分钟
System.out.println("分: " + LocalDateTime.now().getMinute());

//（15）获取秒
System.out.println("秒: " + LocalDateTime.now().getSecond());

//（16）获取纳秒
System.out.println("纳秒: " + LocalDateTime.now().getNano());

(2)计算

//（1）增加天数
System.out.println("增加天数 : " + LocalDateTime.now().plusDays(1));

//（2）增加周数
System.out.println("增加周数 : " + LocalDateTime.now().plusWeeks(1));

//（3）增加月数
System.out.println("增加月数 : " + LocalDateTime.now().plusMonths(1));

//（4）增加年数
System.out.println("增加年数 : " + LocalDateTime.now().plusYears(1));

//（5）减少天数
System.out.println("减少天数 : " + LocalDateTime.now().minusDays(1));

//（6）减少月数
System.out.println("减少月数 : " + LocalDateTime.now().minusMonths(1));

//（7）减少周数
System.out.println("减少周数 : " + LocalDateTime.now().minusWeeks(1));

//（8）减少年数
System.out.println("减少年数 : " + LocalDateTime.now().minusYears(1));

//（9）增加小时
System.out.println("增加1小时: " + LocalDateTime.now().plusHours(1));

//（10）增加分钟
System.out.println("增加30分钟: " + LocalDateTime.now().plusMinutes(30));

//（11）增加秒数
System.out.println("增加30秒: " + LocalDateTime.now().plusSeconds(30));

//（12）增加纳秒
System.out.println("增加10000纳秒:" + LocalDateTime.now().plusNanos(10000));

//（13）减少小时
System.out.println("减少1小时:" + LocalDateTime.now().minusHours(1));

//（14）减少分钟
System.out.println("减少30分钟:" + LocalDateTime.now().minusMinutes(30));

//（15）减少秒数
System.out.println("减少30秒: " + LocalDateTime.now().minusSeconds(30));

//（16）减少纳秒
System.out.println("减少10000纳秒:" + LocalDateTime.now().minusNanos(10000));

(3)比较

//（1）判断日期时间是否相等
System.out.println(LocalDateTime.now().isEqual(LocalDateTime.now()));

//（2）检查是否在指定日期时间之前
System.out.println(LocalDateTime.now().isBefore(LocalDateTime.now()));

//（3）检查是否在指定日期时间之后
System.out.println(LocalDateTime.now().isAfter(LocalDateTime.now()));

(4)LocalDateTime与Date互转

// Date 转化成 LocalDateTime
  public static LocalDateTime dateToLocalDate(Date date) {
    //Date转纳秒
    Instant instant = date.toInstant();
    //获取系统默认的时区
    ZoneId zoneId = ZoneId.systemDefault();
    //转化
    return instant.atZone(zoneId).toLocalDateTime();
  }

// LocalDateTime 转化成 Date
public static Date localDateTimeToDate(LocalDateTime localDateTime) {
    ZoneId zoneId = ZoneId.systemDefault();
    ZonedDateTime zdt = localDateTime.atZone(zoneId);
    return Date.from(zdt.toInstant());
}

// Date 毫秒数据 转化成 LocalDateTime
public static LocalDateTime dateToLocalDateMil(Long datemilli) {
   //将毫秒数据转化为纳秒
   Instant instant = Instant.ofEpochMilli(datemilli);
   ZoneId zoneId = ZoneId.systemDefault();
   return instant.atZone(zoneId).toLocalDateTime();
 }

二、年月日

Year：该类仅代表年，如：2019
YearMonth：该类仅代表年月 如：2019-02
MonthDay：该类仅代表月日，如：09-20
Month：该类是一个枚举类，定义了一月到十二月的枚举值
DayOfWeek：该类是一个枚举类，定义了周日到周六的枚举值

三、时区

ZonedDateTime：该类代表一个时区化的日期、时间 如：2022-01-09T19:50:54.751+08:00[Asia/Shanghai]
ZonedId：该类代表一个时区 Asia/Shanghai
Instant：不可变的类，代表时间戳，精确到纳秒 2022-01-09T11:52:37.879Z

四、时间段

Period：一段日期 
Duration：一段时间
Chronounit：时间单位
Until:计算日期和时间差

4.1、Period（一段日期）

period的单位是year, month 和day

LocalDate startTime = LocalDate.now();
System.out.println("startTime : " + startTime);
LocalDate endTime = LocalDate.now().plusMonths(18);
System.out.println("endTime : " + endTime);

Period p = Period.between(startTime, endTime);
System.out.printf("时间间隔 : %d 年", p.getYears());
System.out.printf("时间间隔 : %d 月 ",p.getMonths());
System.out.printf("时间间隔 : %d 日", p.getDays());
System.out.printf("时间间隔 : %d 年 %d 月 %d 日", p.getYears(), p.getMonths(), p.getDays());

4.2、Duration（一段时间）

duration主要用来衡量秒级和纳秒级的时间，使用于时间精度要求比较高的情况。

LocalDateTime startTime = LocalDateTime.now();
System.out.println("startTime : " + startTime);
LocalDateTime endTime = LocalDateTime.now().plusDays(1).plusHours(1).plusMinutes(1).plusMinutes(1);
System.out.println("endTime : " + endTime);

Duration between = Duration.between(startTime, endTime);
System.out.println("日 "+between.toDays());
System.out.println("时 "+between.toHours());
System.out.println("分 "+between.toMinutes());
System.out.println("秒 "+between.getSeconds());
System.out.println("毫秒"+between.toMillis());

4.3、Chronounit（时间单位）

ChronoUnit 是用来表示时间单位的，但是也提供了一些非常有用的between方法来计算两个时间的差值：

LocalDateTime startTime = LocalDateTime.now();
System.out.println("startTime : " + startTime);
LocalDateTime endTime = LocalDateTime.now().plusYears(1).plusMonths(1)
        .plusWeeks(1).plusDays(1).plusHours(1).plusMinutes(1).plusMinutes(1);
System.out.println("endTime : " + endTime);

long years = ChronoUnit.YEARS.between(startTime, endTime);
System.out.println("日 "+years);
long months = ChronoUnit.MONTHS.between(startTime,endTime);
System.out.println("月 "+months);
long weeks = ChronoUnit.WEEKS.between(startTime,endTime);
System.out.println("周 "+weeks);
long days = ChronoUnit.DAYS.between(startTime,endTime);
System.out.println("日 "+days);
long hours = ChronoUnit.HOURS.between(startTime,endTime);
System.out.println("时 "+hours);
long minutes = ChronoUnit.MINUTES.between(startTime,endTime);
System.out.println("分 "+minutes);
long seconds = ChronoUnit.SECONDS.between(startTime,endTime);
System.out.println("秒 "+seconds);
long millis = ChronoUnit.MILLIS.between(startTime,endTime);
System.out.println("月 "+months);

4.4、Until（时间单位）

until同 四.ChronoUnit类一样，计算有年、月、周、日、时、分、秒、毫秒
计算的是LocalDate和LocalDateTime两个时间分别间隔的年、月、周、日、时、分、秒、毫秒

LocalDateTime startTime = LocalDateTime.now();
System.out.println("startTime : " + startTime);
LocalDateTime endTime = LocalDateTime.now().plusYears(1).plusMonths(1)
        .plusWeeks(1).plusDays(1).plusHours(1).plusMinutes(1).plusMinutes(1);
System.out.println("endTime : " + endTime);

long years = startTime.until(endTime, ChronoUnit.YEARS);
System.out.println("日 "+years);
long months = startTime.until(endTime, ChronoUnit.MONTHS);
System.out.println("月 "+months);
long weeks = startTime.until(endTime, ChronoUnit.WEEKS);
System.out.println("周 "+weeks);
long days = startTime.until(endTime, ChronoUnit.DAYS);
System.out.println("日 "+days);
long hours = startTime.until(endTime, ChronoUnit.HOURS);
System.out.println("时 "+hours);
long minutes = startTime.until(endTime, ChronoUnit.MINUTES);
System.out.println("分 "+minutes);
long seconds = startTime.until(endTime, ChronoUnit.SECONDS);
System.out.println("秒 "+seconds);
long millis = startTime.until(endTime, ChronoUnit.MILLIS);
System.out.println("月 "+months);

五、日期格式化

DateTimeFormatter：可以格式化日期时间，线程安全

六、时间调节器

TemporalAdjuster是一个函数式接口，用来调节时间。
TemporalAdjusters是一个final类，为常用的时间调节器

序号	调节器	作用
1	dayOfWeekInMonth	同一个月中每一周的第几天
2	firstDayOfMonth	当月的第一天
3	firstDayOfNextMonth	下月的第一天
4	firstDayOfNextYear	明年的第一天
5	firstDayOfYear	当年的第一天
6	firstInMonth	同一个月中，第一个符合星期几要求的值
7	lastDayOfMonth	当月的最后一天
8	lastDayOfNextMonth	下月的最后一天
9	lastDayOfNextYear	明年的最后一天
10	lastDayOfYear	今年的最后一天
11	lastInMonth	同一个月中，最后一个符合星期几要求的值

TemporalAdjusters 调节器常用方法

dayOfWeekInMonth　　 同一个月中每一周的第几天
firstDayOfMonth 　　　　当月的第一天
firstDayOfNextMonth 　　下月的第一天
firstDayOfNextYear 　　明年的第一天
firstDayOfYear 　　　　当年的第一天
firstInMonth 　　　　 同一个月中，第一个符合星期几要求的值
lastDayOfMonth 　　　　当月的最后一天
lastDayOfNextMonth 　　下月的最后一天
lastDayOfNextYear 　　明年的最后一天
lastDayOfYear 　　今年的最后一天
lastInMonth 　　同一个月中，最后一个符合星期几要求的值
next/previous　　将其值设定为日期调整后或者调整前，第一个符合指定星期几要求的日期
nextOrSame/previousOrSame 将其值设定为日期调整后或者调整前，第一个符合指定星期几要求的日期，如果该日期已经符合要求，直接返回该对象

七、时钟

Clock: 用于访问当前时刻、日期、时间，用到时区，比如获取目前美国纽约的时间
ZoneOffset：时区偏移量，比如：+8:00