51CTO首页
AI.x社区
博客
学堂
精品班
软考社区
免费课
企业培训
鸿蒙开发者社区
WOT技术大会
IT证书
公众号矩阵
移动端
短视频免费课程课程排行直播课软考学堂
全部课程厂商认证IT技术24年11月软考PMP项目管理免费题库
在线学习
文章资源问答课堂专栏直播
51CTO
鸿蒙开发者社区
51CTO技术栈
51CTO官微
51CTO学堂
51CTO博客
CTO训练营
鸿蒙开发者社区订阅号
51CTO软考
51CTO学堂APP
51CTO学堂企业版APP
鸿蒙开发者社区视频号
51CTO软考题库
账号设置 退出

还在用Calendar操作Date？Java8都被放弃了，你还不知道Java8中全新的日期时间API

作者：码农Academ
开发 前端
本文探讨了Java 8引入的全新日期时间API相较于传统的Date和Calendar类的优势及实际应用。鉴于Java 8新日期时间API在设计上的先进性和易用性，强烈建议积极采纳并替换掉陈旧的Date和Calendar类，转而采用如LocalDate、LocalDateTime、ZonedDateTime等现代日期时间类。

引言

在过去的Java版本中，日期和时间的处理主要依赖于java.util.Date和java.util.Calendar类，然而随着业务系统的复杂以及技术层面的提升，这些传统的日期时间类暴露出了若干显著的不足之处。随着Java8的发布，其引入了一套全新的日期时间API，彻底改变了我们处理日期和时间的方式。

传统的日期时间类

相比较Java8中新引入的java.time包下的时间处理类，传统的日期时间处理类在易用性，线程安全，不支持市时区等缺点。

  1. 设计复杂性：Date类的设计较为简单，但它实际上混合了日期和时间信息，并且没有提供直观的方法来单独操作日期或时间部分。Calendar类虽然提供了更多灵活性，但由于其内部状态和方法的复杂性，使得开发者在使用过程中容易出现错误和混淆，尤其是在进行日期时间计算和格式化时。比如：
Date currentDate = new Date();  
// 输出原始的日期时间，通常不是人类可读格式   Fri Mar 08 03:13:47 CST 2024
System.out.println(currentDate);

// 要改变日期的某个部分，必须先将其转换为 Calendar，然后设置  
Calendar calendar = Calendar.getInstance();  
calendar.setTime(currentDate);  
// 修改日期的天数  
calendar.add(Calendar.DAY_OF_MONTH, 1);
  1. 线程安全性：Date和 Calendar类，以及格式化日期的SimpleDateFormat类都不是线程安全的，这意味着在多线程环境下的并发访问可能会导致数据不一致。

Date类内部维护了一个 long 类型的瞬时值，当调用如setTime()方法来更新这个瞬时值时，不同的线程同时调用就会互相覆盖彼此的值，造成数据不一致。

Calendar类不仅包含了日期和时间信息，还有一系列内部状态变量，如年、月、日、小时、分钟、秒等。Calendar类的方法通常会修改这些内部状态，例如 add()、set() 等。在多线程环境下，若多个线程尝试同时修改同一个 Calendar 实例，也会导致不可预期的结果。

SimpleDateFormat类在执行格式化和解析日期时间操作时，内部会维护一个 Calendar对象以及其他一些状态变量。在 format() 或 parse() 方法执行过程中，这些状态会被更新以完成格式转换。并且SimpleDateFormat中的方法并非原子操作，因此在多线程并发调用时，可能在一个线程还未完成整个操作时就被另一个线程打断，导致错误的日期时间处理结果。

  1. 时区处理能力：Date类虽能表示时间戳，但它不直接关联时区信息，难以进行时区相关的转换。而 Calendar 虽然支持时区，但操作过程相当复杂。
  2. 精度差异：Date类精度只到毫秒级。

Java8中日期时间类

Java8中引入的LocalDate，LocalTime，LocalDateTime这几个位于java.time下的类克服了上述传统类别的局限性，提供了更强大、直观和精准的日期时间处理能力，成为现代Java开发中处理日期时间首选的工具类。相比较传统的日期时间类，具备以下显著优势：

  1. 功能丰富java.time包下的类如 LocalDate、LocalTime、LocalDateTime、ZonedDateTime 等都有明确的职责划分，分别处理日期、时间、日期时间以及带时区的日期时间，结构清晰，易于理解和使用。并且它们提供了一系列直观、面向对象的API，如 plusXxx()、minusXxx()、withXxx()等方法，使日期时间操作变得简单明了。
  2. 时区支持除此之外，还支持时区，通过ZonedDateTime和 ZoneId等类提供了对时区的更好支持，可以方便地进行时区转换和处理。
  3. 线程安全这些类都是不可变对象，线程安全，可以在多线程环境下安全使用，不会出现因并发操作导致的数据不一致问题。
  4. 更高的精度支持纳秒级精度，相比 Date 类的毫秒精度更胜一筹。

java.time下主要有如下一些关键类：

  1. LocalDateLocalDate类表示一个不包含时间信息的日期，只包含年、月、日三个部分，且不关联任何特定时区。
  2. LocalTimeLocalTime类表示一个不包含日期信息的具体时间，包含时、分、秒和纳秒四个部分。
  3. LocalDateTimeLocalDateTime类结合了日期和时间，表示一个具体的日期和时间点，但是不包含时区信息。
  4. ZonedDateTimeZonedDateTime类表示一个带有时区的日期时间，它可以明确表示某一特定时区内的某一确切时间点。
  5. InstantInstant类表示时间线上某一瞬时点，通常以Unix纪元（1970-01-01T00:00:00Z）以来的秒数和纳秒数表示，它是全球通用的时间点表示。
  6. PeriodPeriod类用于表示两个日期之间的期间，包括年、月、日的数量。
  7. DurationDuration类表示两个时间点之间的时间差，包含秒和纳秒的持续时间，主要用于表示时间间隔而非日历单位。
  8. DateTimeFormatterDateTimeFormatter类用于日期时间的格式化和解析，提供了标准化和自定义的日期时间格式化方式。
  9. TemporalAdjustersTemporalAdjusters类提供了一系列实用方法，用于调整日期时间，例如获取下一个工作日、月初、月末等。

这些类共同构成了一个强大、灵活且易于使用的日期时间处理体系，大大改善了Java在处理日期时间问题时的效率和准确性。接下来我们在使用上分别介绍这些类，以及使用他们的方式，感受他们的强大。

Java8中日期时间类使用

创建

NOW方法获取当前 时刻、日期、时间
LocalTime localTime = LocalTime.now();  
System.out.println("localTime："+localTime);  

LocalDate localDate = LocalDate.now();  
System.out.println("localDate："+localDate);  

LocalDateTime localDateTime = LocalDateTime.now();  
System.out.println("localDateTime："+localDateTime);

输出为：

localTime：15:28:45.241181
localDate：2024-03-11
localDateTime：2024-03-11T15:28:45.260655

针对LocalTime，LocalDateTime获取当前时刻默认会带有毫秒，如果不需要毫秒的话，可以通过设置纳秒为0 保留秒 1秒 = 十亿纳秒 。例如：

LocalTime localTime = LocalTime.now().withNano(0);
System.out.println("localTime："+localTime);  

LocalDateTime localDateTime = LocalDateTime.now().withNano(0);  
System.out.println("localDateTime："+localDateTime);

输出为：

localTime：15:32:31
localDateTime：2024-03-11T15:32:31

而对于LocalDateTime获取当前日期，默认toString会带有T分隔日期和时间,在项目中，可以通过全局序列化，进行统一的时间格式输出为 yyyy-MM-dd HH:mm:ss。但是一般不建议这么干，毕竟改变全局序列化配置，建议不使用toString，可以使用DateTimeFormatter进行自定义转换。

of()方法指定年、月、日、时刻创建
// of方法直接传递对应的年、月、日  
LocalDate localDate = LocalDate.of(2024, 3, 11);  
System.out.println("localDate："+localDate);  
localDate = LocalDate.of(2024, Month.MARCH, 11);  
System.out.println("localDate："+localDate);  
localDate = LocalDate.ofYearDay(2024, 71);  
System.out.println("localDate："+localDate);  

// 北京时间对应的时区  
ZoneId chinaTimeZone = ZoneId.of("Asia/Shanghai");  
// 创建一个 Instant，这里使用当前时间的 InstantInstant instant = Instant.now();  
localDate = LocalDate.ofInstant(instant, chinaTimeZone);  
System.out.println("localDate："+localDate);  

// 使用ofEpochDay()方法，则EpochDay为从公元1970年1月1日（Unix纪元）开始的第多少天  
localDate = LocalDate.ofEpochDay(LocalDate.now().toEpochDay());  
System.out.println("localDate："+localDate);  


LocalTime localTime = LocalTime.of(1, 30);  
System.out.println("localTime："+localTime);  
localTime = LocalTime.of(1, 30, 30);  
System.out.println("localTime："+localTime);  

localTime = LocalTime.ofInstant(instant, chinaTimeZone);  
System.out.println("localTime："+localTime);  
// 根据一天中的总秒数构建时间
localTime = LocalTime.ofSecondOfDay(localTime.toSecondOfDay());  
System.out.println("localTime："+localTime);  


LocalDateTime localDateTime = LocalDateTime.of(2024, 3, 11, 1, 30, 30);  
System.out.println("localDateTime："+localDateTime);  
localDateTime = LocalDateTime.of(2024, Month.MARCH, 11, 1, 30, 30);  
System.out.println("localDateTime："+localDateTime);  
// 使用LocalDate和LocalTime组合构造  
localDateTime = LocalDateTime.of(localDate, localTime);  
System.out.println("localDateTime："+localDateTime);  

localDateTime = LocalDateTime.ofInstant(instant, chinaTimeZone);  
System.out.println("localDateTime："+localDateTime);

输出为：

localDate：2024-03-11
localDate：2024-03-11
localDate：2024-03-11
localDate：2024-03-11
localDate：2024-03-11
localTime：01:30
localTime：01:30:30
localTime：16:41:37.893310
localTime：16:41:37
localDateTime：2024-03-11T01:30:30
localDateTime：2024-03-11T01:30:30
localDateTime：2024-03-11T16:41:37
localDateTime：2024-03-11T16:41:37.893310
from()方法转换

from()方法将TemporalAccessor类型（如ZonedDateTime）转换为相对应的日期或者时间。TemporalAccessor接口是一个用于读取或写入日期、时间或者日期时间的通用接口。

// 创建一个ZonedDateTime实例  
ZonedDateTime zonedDateTime = ZonedDateTime.now(ZoneId.of("Asia/Shanghai"));  
LocalTime localTime = LocalTime.from(zonedDateTime);  
System.out.println("localTime："+localTime);  

LocalDate localDate = LocalDate.from(zonedDateTime);  
System.out.println("localDate："+localDate);  

LocalDateTime localDateTime = LocalDateTime.from(zonedDateTime);  
System.out.println("localDateTime："+localDateTime);

输出为：

localTime：17:18:27.942911
localDate：2024-03-11
localDateTime：2024-03-11T17:18:27.942911
parse()方法转换

将字符串按照指定格式（可选）解析为对应的日期时间类。

LocalTime localTime = LocalTime.parse("17:25:30");  
System.out.println("localTime："+localTime);  
localTime = LocalTime.parse("17:25:30", DateTimeFormatter.ofPattern("HH:mm:ss"));  
System.out.println("localTime："+localTime);  

LocalDate localDate = LocalDate.parse("2024-03-11");  
System.out.println("localDate："+localDate);  
localDate = LocalDate.parse("2024/03/11", DateTimeFormatter.ofPattern("yyyy/MM/dd"));  
System.out.println("localDate："+localDate);  

LocalDateTime localDateTime = LocalDateTime.parse("2024-03-11T17:25:30");  
System.out.println("localDateTime："+localDateTime);  
localDateTime = LocalDateTime.parse("2024/03/11 17:25:30", DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss"));  
System.out.println("localDateTime："+localDateTime);

输出为：

localTime：17:25:30
localTime：17:25:30
localDate：2024-03-11
localDate：2024-03-11
localDateTime：2024-03-11T17:25:30
localDateTime：2024-03-11T17:25:30

日期时间类的相互转换

LocalTime、LocalDate、LocalDateTime 相互转化
// LocalTime + LocalDate = LocalDateTime
LocalDateTime localDateTime = LocalTime.now().atDate(LocalDate.now());
System.out.println("localDateTime："+localDateTime);
localDateTime = LocalDate.now().atTime(LocalTime.now());
System.out.println("localDateTime："+localDateTime);
localDateTime = LocalDateTime.of(LocalDate.now(), LocalTime.now());
System.out.println("localDateTime："+localDateTime);

// LocalDateTime 转 LocalDate
LocalDate localDate = LocalDateTime.now().toLocalDate();
System.out.println("localDate："+localDate);
// LocalDateTime 转 LocalTime
LocalTime localTime = LocalDateTime.now().toLocalTime();
System.out.println("localTime："+localTime);

// 获取今日开始时间 2024-03-11T00:00
localDateTime = LocalDate.now().atStartOfDay();
System.out.println("localDateTime："+localDateTime);
// 获取今日开始时间 2024-03-11T00:00
LocalDateTime startDateTime = LocalDateTime.of(LocalDate.now(), LocalTime.MIN);
System.out.println("startDateTime："+ startDateTime);
// 获取今日结束时间 2024-03-11T23:59:59.999999999
LocalDateTime endDateTime = LocalDateTime.of(LocalDate.now(), LocalTime.MAX);
System.out.println("endDateTime："+ endDateTime);

输出为：

localDateTime：2024-03-11T18:04:22.348539
localDateTime：2024-03-11T18:04:22.370562
localDateTime：2024-03-11T18:04:22.370768
localDate：2024-03-11
localTime：18:04:22.371062
localDateTime：2024-03-11T00:00
startDateTime：2024-03-11T00:00
endDateTime：2024-03-11T23:59:59.999999999
String 与 LocalTime、LocalDate、LocalDateTime 相互转化

主要使用format 和 parse 进行转换，使用方法基本相同。使用 DateTimeFormatter.ofPattern() 定义时间格式，再进行转换。DateTimeFormatter线程安全。

// LocalTime 转 String 自定义输出格式，例如：**时**分**秒 该转化的 00 不会被省略
String localTimeStr = LocalTime.now().format(DateTimeFormatter.ofPattern("HH时mm分ss秒"));
System.out.println("localTimeStr:"+localTimeStr);

String localDateStr = LocalDate.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));
System.out.println("localDateStr:"+localDateStr);

// LocalDateTime 转 String
String localDateTimeStr = LocalDateTime.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
System.out.println("localDateTimeStr:"+localDateTimeStr);

// String 转 LocalDateTime
LocalDateTime localDateTime = LocalDateTime.parse("2023-04-14 15:59:40", DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
System.out.println("localDateTime："+localDateTime);

输出结果：

localTimeStr:19时02分58秒
localDateStr:2024-03-11
localDateTimeStr:2024-03-11 19:02:58
localDateTime：2023-04-14T15:59:40
Date 与 LocalDate、LocalDateTime 相互转化
// Date 转 LocalDateTime
Date currentDate = new Date();
// 转换为Instant 
Instant instant = currentDate.toInstant();
// 通过zoneId设置时区(这里使用系统时区)，转换为带带时区的 ZoneDateTime
ZonedDateTime zonedDateTime = instant.atZone(ZoneId.systemDefault());
// 然后通过ZonedDateTime转换为LocalDateTime
LocalDateTime localDateTime = zonedDateTime.toLocalDateTime();
System.out.println("localDateTime："+localDateTime);
// LocalDateTime 转 Date，同理也是通过ZonedDateTime转换为Date
Date localDateTimeToDate = Date.from(LocalDateTime.now().atZone(ZoneId.systemDefault()).toInstant());
System.out.println(localDateTimeToDate);
// Date转LocalDate 同理 LocalDateTime转换
LocalDate localDate = currentDate.toInstant().atZone(ZoneId.systemDefault()).toLocalDate();
System.out.println("localDate："+localDate);
// LocalDate 转 Date  需要先将 LocalDate 转 LocalDateTime
Date localDateToDate = Date.from(LocalDate.now().atStartOfDay(ZoneId.systemDefault()).toInstant());

这里介绍一下ZoneId。java.time.ZoneId是Java 8中java.time包中用于表示时区的类。时区是地球上的地理位置，用于确定在该位置观察太阳升落以及规定当地居民生活和商业活动时间的标准时间。ZoneId使用IANA时区数据库提供的时区标识符，这个标识符是唯一的，这些标识符通常是地区/城市对，例如“Asia/Shanghai”代表中国上海所在的时区，America/New_York代表美国纽约城市。其实例获取有两种方式：

  • ZoneId.systemDefault()：获取系统默认的时区ID。
  • ZoneId.of(String zoneId)：根据提供的时区ID字符串获取ZoneId实例。至于zoneId的值，可以查看源码。可以通过ZoneId.getAvailableZoneIds()查看获取。
Long 与 LocalDate、LocalDateTime 相互转化

时间戳转换。

long timeMillis = System.currentTimeMillis();

// 时间戳(Long) 转 LocalDateTime
LocalDateTime localDateTime = Instant.ofEpochMilli(timeMillis).atZone(ZoneOffset.ofHours(8)).toLocalDateTime();
System.out.println("localDateTime："+localDateTime);
localDateTime = Instant.ofEpochMilli(timeMillis).atZone(ZoneId.systemDefault()).toLocalDateTime();
System.out.println("localDateTime："+localDateTime);
// LocalDateTime 转 时间戳(Long) 秒级
long localDateTimeToSecond = LocalDateTime.now().toEpochSecond(ZoneOffset.ofHours(8));
System.out.println("localDateTimeToSecond："+ localDateTimeToSecond);
// LocalDateTime 转 时间戳(Long) 毫秒级
long localDateTimeToMilliSecond = LocalDateTime.now().toInstant(ZoneOffset.ofHours(8)).toEpochMilli();
System.out.println("localDateTimeToMilliSecond："+ localDateTimeToMilliSecond);

// 时间戳(Long) 转 LocalDate
LocalDate localDate = Instant.ofEpochMilli(timeMillis).atZone(ZoneOffset.ofHours(8)).toLocalDate();
System.out.println("localDate："+ localDate);
// LocalDate 转 时间戳(Long) 秒级
long localDateToSecond =  LocalDate.now().atStartOfDay().toEpochSecond(ZoneOffset.ofHours(8));
System.out.println("localDateToSecond："+ localDateToSecond);
// LocalDate 转 时间戳(Long) 毫秒级
long localDateToMilliSecond = LocalDate.now().atStartOfDay().toInstant(ZoneOffset.ofHours(8)).toEpochMilli();
System.out.println("localDateToMilliSecond："+ localDateToMilliSecond);

输出结果为：

localDateTime：2024-03-11T19:37:02.335
localDateTime：2024-03-11T19:37:02.335
localDateTimeToSecond：1710157022
localDateTimeToMilliSecond：1710157022365
localDate：2024-03-11
localDateToSecond：1710086400
localDateToMilliSecond：1710086400000

java.time.ZoneOffset是Java8中java.time包内用来表示时区偏移量的类，它表示的是格林尼治标准时间或协调世界时间（UTC）基础上的固定偏移量。每一个时区都可以通过一个或多个偏移量来表示，比如“+02:00”表示比UTC时间快两个小时的时区偏移。其实例创建有如下方式：

  • ZoneOffset.ofHours(int hours)：根据小时数创建偏移量，例如 ZoneOffset.ofHours(2) 表示比UTC早2小时的时区。
  • ZoneOffset.ofHoursMinutes(int hours, int minutes)：根据小时数和分钟数创建偏移量。
  • ZoneOffset.ofHoursMinutesSeconds(int hours, int minutes, int seconds)：根据小时、分钟和秒数创建偏移量。
  • ZoneOffset.ofTotalSeconds(int totalSeconds)：根据相对于UTC的总秒数创建偏移量。
  • ZoneOffset.of(String offsetId)：根据偏移量ID（如 "+02:00"）创建实例。

日期时间类的操作

日期时间的增减

java.time 包中日期时间类（如 LocalDateTime、LocalDate 和 LocalTime）可以通过plusXxx() 和 minusXxx() 方法，用于对日期时间对象进行加减操作，以增加或减少指定的时间或日期单位。

1、LocalDateTime 加减：

  • plusHours(int hours), plusMinutes(int minutes), plusSeconds(int seconds)：分别用于向 LocalDateTime 对象添加指定的小时数、分钟数和秒数。
  • plus(1, ChronoUnit.XXX)：这里的 ChronoUnit 参数可以是 HOURS、MINUTES、SECONDS 等，也可以是 YEARS、MONTHS、DAYS、WEEKS 等，用于向日期时间对象添加指定单位的数量。
  • plus(Duration duration)：使用 Duration 对象来增加时间，Duration 可以包含秒和纳秒的精度。
  • plus(Period period)：使用 Period 对象来增加日期，Period 可以表示年、月、日的数量。
  • 与plusXxx() 方法相对应，minusXxx() 方法用于从日期时间对象中减少指定的单位。例如 minusHours(int hours)、minusMinutes(int minutes)、minusSeconds(int seconds) 等方法用于减少小时、分钟、秒数。
// LocalDateTime 加减
LocalDateTime localDateTime = LocalDateTime.now();
// 以下为增加时、分、秒
LocalDateTime plusLocalDateTime = localDateTime.plusHours(1).plusMinutes(1).plusSeconds(1);
System.out.println("plusLocalDateTime："+plusLocalDateTime);
plusLocalDateTime = localDateTime.plus(1, ChronoUnit.HOURS).plus(1, ChronoUnit.MINUTES).plus(1, ChronoUnit.SECONDS);
System.out.println("plusLocalDateTime："+plusLocalDateTime);
plusLocalDateTime = localDateTime.plus(Duration.ofHours(1)).plus(Duration.of(1, ChronoUnit.MINUTES)).plus(Duration.of(1, ChronoUnit.SECONDS));
System.out.println("plusLocalDateTime："+plusLocalDateTime);

// 以下为增加年、月、日
plusLocalDateTime = localDateTime.plusYears(1).plusMonths(1).plusWeeks(1).plusDays(1);
System.out.println("plusLocalDateTime："+plusLocalDateTime);
plusLocalDateTime = localDateTime.plus(1, ChronoUnit.YEARS).plus(1, ChronoUnit.MONTHS).plus(1, ChronoUnit.WEEKS).plus(1, ChronoUnit.DAYS);
System.out.println("plusLocalDateTime："+plusLocalDateTime);
plusLocalDateTime = localDateTime.plus(Duration.of(1, ChronoUnit.YEARS)).plus(Duration.of(1, ChronoUnit.MONTHS)).plus(Duration.of(1, ChronoUnit.WEEKS)).plus(Duration.ofDays(1));
System.out.println("plusLocalDateTime："+plusLocalDateTime);
plusLocalDateTime = localDateTime.plus(Period.ofYears(1)).plus(Period.ofMonths(1)).plus(Period.ofWeeks(1)).plus(Period.ofDays(1));
System.out.println("plusLocalDateTime："+plusLocalDateTime);

// 以下为减少时、分、秒
LocalDateTime minusLocalDateTime = localDateTime.minusHours(1).minusMinutes(1).minusSeconds(1);
System.out.println("minusLocalDateTime："+minusLocalDateTime);
minusLocalDateTime = localDateTime.minus(1, ChronoUnit.HOURS).minus(1, ChronoUnit.MINUTES).minus(1, ChronoUnit.SECONDS);
System.out.println("minusLocalDateTime："+minusLocalDateTime);
minusLocalDateTime = localDateTime.minus(Duration.ofHours(1)).minus(Duration.of(1, ChronoUnit.MINUTES)).minus(Duration.of(1, ChronoUnit.SECONDS));
System.out.println("minusLocalDateTime："+minusLocalDateTime);

// 以下为减少年、月、日
minusLocalDateTime = localDateTime.minusYears(1).minusMonths(1).minusWeeks(1).minusDays(1);
System.out.println("minusLocalDateTime："+minusLocalDateTime);
minusLocalDateTime = localDateTime.minus(1, ChronoUnit.YEARS).minus(1, ChronoUnit.MONTHS).minus(1, ChronoUnit.WEEKS).minus(1, ChronoUnit.DAYS);
System.out.println("minusLocalDateTime："+minusLocalDateTime);
minusLocalDateTime = localDateTime.minus(Duration.of(1, ChronoUnit.YEARS)).minus(Duration.of(1, ChronoUnit.MONTHS)).minus(Duration.of(1, ChronoUnit.WEEKS)).minus(Duration.ofDays(1));
System.out.println("minusLocalDateTime："+minusLocalDateTime);
minusLocalDateTime = localDateTime.minus(Period.ofYears(1)).minus(Period.ofMonths(1)).minus(Period.ofWeeks(1)).minus(Period.ofDays(1));
System.out.println("plusLocalDateTime："+minusLocalDateTime);

2、LocalDate 加减：

  • 同样的，plusYears(int years), plusMonths(int months), plusDays(int days) 分别用于增加年、月、日。
  • plus(1, ChronoUnit.XXX)和plus(Duration/Period duration/period) 方法在此同样适用，用于增加指定的日期单位。
  • 与plusXxx() 方法相对应，minusXxx() 方法用于从日期时间对象中减少指定的单位。例如 minusYears(int years)、minusMonths(int months)、minusWeeks(int weeks)、minusDays(int days) 等方法用于减少年、月、周、天数。
// LocalDate 加减
LocalDate localDate = LocalDate.now();
LocalDate plusLocalDate = localDate.plusYears(1).plusMonths(1).plusWeeks(1).plusDays(1);
System.out.println("plusLocalDate："+plusLocalDate);
plusLocalDate = localDate.plus(1, ChronoUnit.YEARS).plus(1, ChronoUnit.MONTHS).plus(1, ChronoUnit.WEEKS).plus(1, ChronoUnit.DAYS);
System.out.println("plusLocalDate："+plusLocalDate);
plusLocalDate = localDate.plus(Duration.of(1, ChronoUnit.YEARS)).plus(Duration.of(1, ChronoUnit.MONTHS)).plus(Duration.of(1, ChronoUnit.WEEKS)).plus(Duration.ofDays(1));
System.out.println("plusLocalDate："+plusLocalDate);
plusLocalDate = localDate.plus(Period.ofYears(1)).plus(Period.ofMonths(1)).plus(Period.ofWeeks(1)).plus(Period.ofDays(1));
System.out.println("plusLocalDate："+plusLocalDate);

LocalDate minusLocalDate = localDate.minusYears(1).minusMonths(1).minusWeeks(1).minusDays(1);
System.out.println("minusLocalDate："+minusLocalDate);
minusLocalDate = localDate.minus(1, ChronoUnit.YEARS).minus(1, ChronoUnit.MONTHS).minus(1, ChronoUnit.WEEKS).minus(1, ChronoUnit.DAYS);
System.out.println("minusLocalDate："+minusLocalDate);
minusLocalDate = localDate.minus(Duration.of(1, ChronoUnit.YEARS)).minus(Duration.of(1, ChronoUnit.MONTHS)).minus(Duration.of(1, ChronoUnit.WEEKS)).minus(Duration.ofDays(1));
System.out.println("minusLocalDate："+minusLocalDate);
minusLocalDate = localDate.minus(Period.ofYears(1)).minus(Period.ofMonths(1)).minus(Period.ofWeeks(1)).minus(Period.ofDays(1));
System.out.println("minusLocalDate："+minusLocalDate);

3、LocalTime 加减：

  • plusHours(int hours), plusMinutes(int minutes), plusSeconds(int seconds)：分别用于向 LocalTime 对象添加指定的小时数、分钟数和秒数。
  • 同样支持 plus(1, ChronoUnit.XXX) 和 plus(Duration duration) 方法，用于增加时间单位。
  • 与 plusXxx() 方法相对应，minusXxx() 方法用于从日期时间对象中减少指定的单位。minus(1, ChronoUnit.XXX), minus(Duration duration), minus(Period period) 方法也分别用于减少指定的日期或时间单位。例如 minusHours(int hours)、minusMinutes(int minutes)、minusSeconds(int seconds) 等方法用于减少小时、分钟、秒数。
// LocalTime 加减
LocalTime localTime = LocalTime.now();
LocalTime plusLocalTime = localTime.plusHours(1).plusMinutes(1).plusSeconds(1);
System.out.println("plusLocalTime："+plusLocalTime);
plusLocalTime = localTime.plus(1, ChronoUnit.HOURS).plus(1, ChronoUnit.MINUTES).plus(1, ChronoUnit.SECONDS);
System.out.println("plusLocalTime："+plusLocalTime);
plusLocalTime = localTime.plus(Duration.ofHours(1)).plus(Duration.of(1, ChronoUnit.MINUTES)).plus(Duration.of(1, ChronoUnit.SECONDS));
System.out.println("plusLocalTime："+plusLocalTime);

LocalTime minusLocalTime = localTime.minusHours(1).minusMinutes(1).minusSeconds(1);
System.out.println("minusLocalTime："+minusLocalTime);
minusLocalTime = localTime.minus(1, ChronoUnit.HOURS).minus(1, ChronoUnit.MINUTES).minus(1, ChronoUnit.SECONDS);
System.out.println("minusLocalDateTime："+minusLocalTime);
minusLocalTime = localTime.minus(Duration.ofHours(1)).minus(Duration.of(1, ChronoUnit.MINUTES)).minus(Duration.of(1, ChronoUnit.SECONDS));
System.out.println("minusLocalDateTime："+minusLocalTime);
日期时间修改指定值

LocalDate、LocalTime、LocalDateTime、ZonedDateTime可以通过相对应的withXxx()方法修改指定的值。

1、LocalDate：

  • LocalDate.withYear(int year)：修改年份字段。
  • LocalDate.withMonth(int month)：修改月份字段（注意月份是从1开始计数的）。
  • LocalDate.withDayOfMonth(int dayOfMonth)：修改日期字段。
LocalDate localDate = LocalDate.of(2024, 3, 12);
LocalDate newDate = localDate.withYear(2025).withMonth(4).with(ChronoField.DAY_OF_MONTH, 13);
System.out.println("newDate："+newDate);

2、LocalTime：

  • LocalTime.withHour(int hour)：修改小时字段。
  • LocalTime.withMinute(int minute)：修改分钟字段。
  • LocalTime.withSecond(int second)：修改秒字段。
  • LocalTime.withNano(int nanoOfSecond)：修改纳秒字段。
LocalTime localTime = LocalTime.of(17, 25, 30);
LocalTime newTime = localTime.withHour(18).withMinute(26).with(ChronoField.SECOND_OF_MINUTE, 31);
System.out.println("newTime："+newTime);

3、LocalDateTime：

  • LocalDateTime.withYear(int year)
  • LocalDateTime.withMonth(int month)
  • LocalDateTime.withDayOfMonth(int dayOfMonth)
  • LocalDateTime.withHour(int hour)
  • LocalDateTime.withMinute(int minute)
  • LocalDateTime.withSecond(int second)
  • LocalDateTime.withNano(int nanoOfSecond)
LocalDateTime localDateTime = LocalDateTime.of(2024, 3, 12, 17, 25, 30);
LocalDateTime newDateTime = localDateTime.withYear(2025).withMonth(4).with(ChronoField.DAY_OF_MONTH, 13).withHour(18).withMinute(26).with(ChronoField.SECOND_OF_MINUTE, 31);
System.out.println("newDateTime："+ newDateTime);

4、ZonedDateTime：

  • 除了上述的日期和时间字段外，还有时区相关的 withZoneSameInstant(ZoneId zone) 方法，可以改变时区的同时保持同一瞬间不变。
ZonedDateTime zonedDateTime = ZonedDateTime.of(2024, 3, 12, 17, 25, 30, 0, ZoneId.of("Europe/London"));
ZonedDateTime newZonedDateTime = zonedDateTime.withZoneSameInstant(ZoneId.of("America/New_York"));
System.out.println("newZonedDateTime："+ newZonedDateTime);

除此之外，调整日期时间还可以通过TemporalAdjusters，TemporalAdjuster 是一个函数式接口，用于根据给定的规则调整日期时间对象。Java8的 java.time.temporal 包中预定义了一系列常用的 TemporalAdjuster 实现，例如获取下一个工作日、月初、月末等。

LocalDate date = LocalDate.of(2024, 3, 11);
// 下一个工作日
LocalDate nextWorkingDay = date.with(TemporalAdjusters.next(DayOfWeek.MONDAY)); // 如果11号不是周一，则返回下一个周一的日期
// 下一个月的第一天
LocalDate firstDayNextMonth = date.with(TemporalAdjusters.firstDayOfMonth()); // 返回4月1日
// 当月的最后一个工作日
LocalDate lastWorkingDay = date.with(TemporalAdjusters.lastInMonth(DayOfWeek.FRIDAY)); // 返回3月最后一个周五的日期

// 自定义 TemporalAdjuster
TemporalAdjuster adjuster = temporal -> {
    return temporal.plusDays(10).with(TemporalAdjusters.lastDayOfMonth());
};
LocalDate tenthDayNextMonthEnd = date.with(adjuster); // 返回4月最后一个日期，前提是先加10天
日期时间的比较

在Java8及其以后版本的日期时间API中，isBefore() 和 isAfter() 方法是 java.time 包中的 LocalDate、LocalTime、LocalDateTime、ZonedDateTime 等日期时间类所共有的方法，用于比较两个日期时间对象的先后顺序。

isBefore()：

  • 此方法用于判断当前对象是否早于另一个日期时间对象。
  • 如果当前对象的时间点在参数对象之前，则返回 true；否则返回 false。
LocalDate date1 = LocalDate.of(2024, 3, 11);
LocalDate date2 = LocalDate.of(2024, 3, 12);
boolean isEarlier = date1.isBefore(date2); // 返回 true，因为 date1 在 date2 之前

isAfter()：

  • 此方法用于判断当前对象是否晚于另一个日期时间对象。
  • 如果当前对象的时间点在参数对象之后，则返回 true；否则返回 false。
LocalDateTime time1 = LocalDateTime.of(2024, 3, 11, 10, 0);
LocalDateTime time2 = LocalDateTime.of(2024, 3, 11, 9, 0);
boolean isLater = time1.isAfter(time2); // 返回 true，因为 time1 在 time2 之后

compareTo()在Java 8的 java.time 包中，大部分日期时间类如 LocalDate、LocalTime、LocalDateTime、ZonedDateTime 都实现了 Comparable 接口，从而可以直接使用 compareTo() 方法进行比较。compareTo() 方法用于比较两个日期时间对象的先后顺序，返回值含义如下：

  • 如果当前对象早于（时间点在前）参数对象，返回负数。
  • 如果当前对象等于参数对象，返回0。
  • 如果当前对象晚于（时间点在后）参数对象，返回正数。
LocalDate date1 = LocalDate.of(2024, 3, 11);
LocalDate date2 = LocalDate.of(2024, 3, 12);

int comparisonResult = date1.compareTo(date2);

if (comparisonResult < 0) {
    System.out.println("date1 is before date2");
} else if (comparisonResult > 0) {
    System.out.println("date1 is after date2");
} else {
    System.out.println("date1 is equal to date2");
}

LocalDateTime dateTime1 = LocalDateTime.of(2024, 3, 11, 10, 30);
LocalDateTime dateTime2 = LocalDateTime.of(2024, 3, 11, 11, 00);

int timeComparisonResult = dateTime1.compareTo(dateTime2);
其他操作

在Java8的 java.time 包中，各个日期时间类如 LocalDate、LocalTime、LocalDateTime 提供了一系列 get 方法，用于获取特定字段的值。

获取日期中的特定字段：

LocalDate date = LocalDate.of(2024, 3, 11);
int dayOfMonth = date.getDayOfMonth(); // 获取当月的第几天，此处返回11
int monthValue = date.getMonthValue(); // 获取月份值，此处返回3
Month month = date.getMonth(); // 获取Month枚举，此处返回March
int year = date.getYear(); // 获取年份，此处返回2024

对于时间部分，类似地可以获取小时、分钟、秒和纳秒：

LocalTime time = LocalTime.of(19, 30, 45);
int hour = time.getHour(); // 获取小时数，此处返回10
int minute = time.getMinute(); // 获取分钟数，此处返回30
int second = time.getSecond(); // 获取秒数，此处返回45
int nano = time.getNano(); // 获取纳秒数

在SpringBoot中使用

SpringBoot默认集成了Jackson作为JSON处理库，Jackson已经能自动处理 LocalDate、LocalTime 和 LocalDateTime 类型。

如果需要使用自定义日期时间格式，我们有两种方式：

手动更改全局配置： 如果需要自定义日期格式，可以通过 ObjectMapper 的配置类来注册自定义的日期格式化器：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-json</artifactId>
</dependency>
@Configuration
public class JacksonConfig {
    @Bean
    public Jackson2ObjectMapperBuilderCustomizer jsonCustomizer() {
        return builder -> {
            builder.simpleDateFormat("yyyy-MM-dd");
            // 使用Java 8时间API的日期格式器
            builder.dateFormat(new StdDateFormat().withColonInTimeZone(true));
            // 注册LocalDateTime的序列化和反序列化模块
            builder.modules(new JavaTimeModule());
        };
    }
}

手动绑定格式化配置SpringBoot支持自动绑定HTTP请求参数到控制器方法参数中，包括 LocalDate、LocalTime 和 LocalDateTime 类型。客户端需发送符合日期格式的字符串，Spring Boot会自动转换成相应类型。

@PostMapping("/events")
    public ResponseEntity<Event> createEvent(@RequestParam @DateTimeFormat(pattern = "yyyy-MM-dd") LocalDate date,
                                             @RequestParam @DateTimeFormat(pattern = "HH:mm:ss") LocalTime startTime,
                                             @RequestParam @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss") LocalDateTime timestamp) {
        // ...
    }

或者请求或者响应VO中：

public static class ResponseVO{

        @DateTimeFormat(pattern = "yyyy-MM-dd")
        private  LocalDate date;

        @DateTimeFormat(pattern = "HH:mm:ss") 
        private LocalTime startTime;

        @DateTimeFormat(pattern = "yyyy-MM-dd HH:mm:ss")
        private  LocalDateTime timestamp;
    }

Mybatis中使用

在MyBatis中查询MySQL数据库时，使用Java 8的 java.time.LocalDate、java.time.LocalTime 和 java.time.LocalDateTime类型。

  1. 数据库表结构： 在MySQL数据库中，通常需要使用适合的日期时间类型来存储这些Java 8的日期时间对象。例如：

LocalDate 对应MySQL的DATE类型。LocalTime 对应MySQL 的 TIME 类型。LocalDateTime 对应MySQL的 DATETIME或TIMESTAMP类型。

CREATE TABLE `test_date`(
    `id` BIGINT ( 20 ) UNSIGNED NOT NULL AUTO_INCREMENT COMMENT '自增主键',
    test_local_date DATE ,
    test_local_time TIME,
    test_local_date_time DATETIME,
    PRIMARY KEY ( `id` )
)
ENGINE = INNODB AUTO_INCREMENT = 1 DEFAULT CHARSET = utf8mb4 COMMENT = '日期时间测试';
  1. 实体类映射： 在Java实体类中，对应字段应声明为 LocalDate、LocalTime 或 LocalDateTime 类型。
@Data
public class TestDate implements Serializable {
    /**
    * 自增主键
    */
    private Long id;

    private LocalDate testLocalDate;

    private LocalTime testLocalTime;

    private LocalDateTime testLocalDateTime;

    private static final long serialVersionUID = 1L;
}

3.MyBatis配置：

  • 自动类型转换：如果你使用的是较新的MyBatis版本（>=3.4.5），MyBatis已经内置了对Java 8日期时间类型的处理。这意味着在执行SQL查询时，MyBatis会自动将数据库中的日期时间字段转换为相应的Java8类型。
@Test
public void testInsertDate(){
    TestDate testDate = new TestDate();
    testDate.setTestLocalDate(LocalDate.of(2024, 3, 12));
    testDate.setTestLocalTime(LocalTime.of(20,10,30));
    testDate.setTestLocalDateTime(LocalDateTime.of(2024, 3, 12,20,10,30,0));
    testDateMapper.insert(testDate);
}

@Test
public void testQueryDate(){
    TestDate testDate = testDateMapper.selectByPrimaryKey(1L);
    System.out.println("testLocalDate:"+testDate.getTestLocalDate());
    System.out.println("testLocalTime:"+testDate.getTestLocalTime());
    System.out.println("testLocalDateTime:"+testDate.getTestLocalDateTime());
}

image.png

  • 自定义TypeHandler：如果MyBatis版本较低或者需要自定义日期时间格式，你可能需要自定义 TypeHandler 来处理 LocalDate、LocalTime 和 LocalDateTime 与数据库字段间的转换。关于Mybatis使用自定义TypeHandler，请移步：玩转Mybatis：自定义TypeHandler，轻松应对Mysql的JSON类型操作

结论

本文探讨了Java 8引入的全新日期时间API相较于传统的Date和Calendar类的优势及实际应用。鉴于Java 8新日期时间API在设计上的先进性和易用性，强烈建议积极采纳并替换掉陈旧的Date和Calendar类，转而采用如LocalDate、LocalDateTime、ZonedDateTime等现代日期时间类。

Java 8新日期时间API提供了更为清晰、直观的操作接口，支持不可变对象设计模式，增强了类型安全性，并具备丰富的日期时间运算、解析与格式化功能，显著提高了代码质量与可读性。此外，新API对日期时间单位的精确度控制、时区管理以及与其他日期时间规范的兼容性等方面均表现出卓越的表现力和灵活性，使得我们在处理各类复杂日期时间逻辑时能够更加得心应手，提升开发效率。

责任编辑：武晓燕 来源： 码农Academ
CalendaJava8Date
相关推荐
Java8 日期/时间（Date Time）API指南
Java8日期时间（DateTime）API是开发人员最受追捧的变化之一，Java从一开始就没有对日期时间处理的一致性方法，因此日期时间API也是除Java核心API以外另一项倍受欢迎的内容。

2014-12-22 10:14:31

Java8
Java8全新日期、时间API在这全明白了
在Java1.0中，对日期和时间的支持只能依赖java.util.Date类。这个类无法表示日期，只能以毫秒的精度表示时间。而且设计不合理，比如：年份的起始选择是1900年，月份的起始从0开始。

2023-01-10 08:27:35

Java8APIJava
放弃 StringBuilder！用Java8的StringJoiner
在阅读项目代码时，突然看到了StringJoiner这个类的使用，感觉很有意思。对实际开发中也有用，原理上是运用了StringBuilder的一个拼接字符串的封装处理。

2021-08-13 12:53:42

StringBuildStringJoineJava
大厂如何使用Java8日期时间?
我们生活在最好的时代，基本主流类库都支持新日期时间类型，但还有项目因还是用祖传日期时间类，出现很多古今交错的错误实践。

2020-12-01 07:18:35

Java8日期时间
字符串拼接还在用StringBuilder？快试试Java8中的StringJoiner吧，真香！
我们经常会通过StringBuffer或者StingBuilder对字符串进行拼接，但是你知道Java8中推出的StringJoiner吗？它比前者更加优美、灵活，如果你现在还使用StringBuffer拼接，强烈推荐你试试StringJoiner。

2021-04-21 10:36:47

StringBuildJava8StringJoine
还不知道微软这个工具你就out了！
12月份对于大学生们来说有两个考试，一个是英语四六级，还有一个自然是考研，而今天我们主要针对英文作文写作，当然本文不是教你怎么写英语作文。

2019-12-24 09:49:02

微软英语浏览器
“云计算”哪些你还不知道？
现在，云计算高速发展，关于云计算的资讯中有哪些是您不能错过的呢？小编带您一起阅读我们不能错过的云计算！

2016-07-22 17:55:07

云计算
Java8中时间日期库的20个常用使用示例
除了lambda表达式，stream以及几个小的改进之外，Java8还引入了一套全新的时间日期API，在本篇教程中我们将通过几个简单的任务示例来学习如何使用Java8的这套API。Java对日期，日历及时间的处理一直以来都饱受诟病，尤其是它决定将java.util.Date定义为可修改的以及将SimpleDateFormat实现成非线程安全的。

2016-11-29 12:46:24

JavaJava8时间日期库
SCSS 中这些技巧，你可能还不知道！
这篇文章会跟随工程化前端一步一步记录sass中那些不为人知，但是又非常使用的小技巧分享给大家。

2022-05-05 12:02:45

SCSS函数开发
Java8 Stream流API使用简介
流API是一套功能强大但易于理解的工具，用于处理元素序列。如果使用得当，它可以减少大量代码，创建更可读的程序，并提高应用程序的生产力。在应用程序中，不要让实例化的流未被使用，避免导致内存泄漏。

2023-05-12 07:40:01

Java8API工具
你不知道的Java秘密
本文向各位介绍一下Java性能监控小技巧：“JDK附带分析器、远程连接进程、跟踪统计、为离线分析创建一个堆转储、JConsole并不是高深莫测的。”

2010-08-23 09:56:09

Java性能监控
Spring Cloud 精妙的设计，你还不知道？
本文将通过大量的手绘图，给大家谈谈SpringCloud微服务架构的底层原理。

2022-07-17 06:53:24

微服务架构
都已经2023年了，你还不知道StampedLock吗？
本文主要讲解了StampedLock​的功能和使用，至于原理，StampedLock虽然不像其它锁一样定义了内部类来实现AQS框架，但是StampedLock的基本实现思路还是利用CLH队列进行线程的管理，通过同步状态值来表示锁的状态和类型，具体的源码实现大家感兴趣的自己可以追踪看看。

2023-01-02 10:08:42

StampedLocAQS框架
Java8中的Stream那么彪悍，你知道它的原理是什么吗？
StreamAPI可以极大提高Java程序员的生产力，让程序员写出高效率、干净、简洁的代码。本文会对Stream的实现原理进行剖析。

2021-02-18 16:06:43

JavaStream代码
什么年代了，你还不知道 Servlet3.0 中的文件上传方式？
其实文件上传这块松哥之前和大家聊过很多次了，这次因为最近正在进行SpringMVC的源码分析，所以又再次把这个话题拉出来“鞭尸”，不过这次松哥想从源码角度来聊聊这个话题。

2021-04-15 12:30:18

ServletSpringMVC 版本
8个超实用的iPhone隐藏功能和技巧，你可能还不知道
生活中有很多朋友都在用iPhone，那么今天给大家分享，8个超实用的iPhone隐藏功能和技巧，你可能还不知道，下面一起来看看吧。

2021-05-12 10:48:02

苹果技巧功能
Spring Boot和Feign中使用Java 8时间日期API（LocalDate等）的序列化问题
LocalDate、LocalTime、LocalDateTime是Java8开始提供的时间日期API，主要用来优化Java8以前对于时间日期的处理操作。

2018-06-13 15:48:21

Spring BootJava 8API
8 个你可能不知道的 Docker 知识
在过去的一年内，Docker技术已经逐渐走向成熟。当我几年前第一次直到Docker的时候，我还对Docker的未来持怀疑的态度，我认为他们是把以前的Linux容器的概念拿出来包装了一番推向市场。但是使用Docker成功进行了几个项目例如Spantree之后，我改变了我的看法：Docker帮助我们节省了大量的时间和经历，并且已经成为我们技术团队中不可或缺的工具。

2015-05-14 15:59:33

DockerLinux容器管理工具
17个你可能还不知道 JS 技巧！
17个你可能还不知道JS技巧！你知道吗？

2020-12-14 07:51:16

JS 技巧虚值
这些Python代码技巧，你肯定还不知道
被人工智能捧红的Python已是一种发展完善且非常多样化的语言，其中肯定有一些你尚未发现的功能。本文或许能够让你学到一些新技巧。

2018-09-02 15:43:56

Python代码编程语言
点赞
收藏

51CTO技术栈公众号

业务
速览
在线客服