现代java日期时间处理推荐使用java.time包。1. 核心类包括localdate、localtime、localdatetime、zoneddatetime和instant，分别表示日期、时间、日期时间、带时区的日期时间和时间戳；2. 所有类均为不可变对象，保证线程安全；3. 通过now()和of()方法创建实例，支持链式调用进行加减操作；4. 使用datetimeformatter进行日期时间的格式化与解析，需注意模式匹配和locale设置；5. duration用于计算以秒或纳秒为单位的时间差，period用于计算以年、月、日为单位的日期差；6. 时区通过zoneid和zoneddatetime处理，支持跨时区转换。该api设计清晰、语义明确、线程安全，彻底解决了旧date和calendar类的诸多缺陷，是java日期时间操作的现代标准解决方案。
Java处理日期时间，现在主流且推荐的方式是使用
java.time
包，也就是常说的JSR 310。它彻底解决了老旧
java.util.Date
和
Calendar
的诸多痛点，让日期操作变得直观且安全。简单来说，如果你还在用
Date
和
Calendar
，是时候升级你的知识库了，
java.time
才是现代Java日期处理的答案。
解决方案
要高效且优雅地处理Java中的日期时间，核心就是拥抱并熟练运用
java.time
包下的API。这套API设计得非常精妙，它将日期、时间、日期时间、时区、时间段等概念清晰地分离，每个类都专注于一个特定的职责。比如，
LocalDate
只表示日期，没有时间；
LocalTime
只表示时间，没有日期；
LocalDateTime
则兼具日期和时间，但不包含时区信息。
我个人觉得，理解这几个核心类的区别是第一步。当你需要处理“今天是什么日子”时，用
LocalDate
；当你想知道“现在是几点几分”时，用
LocalTime
；而“2023年10月26日下午3点半”这种，就交给
LocalDateTime
。如果涉及到跨时区或者需要精确到毫秒甚至纳秒的时间点，
ZonedDateTime
和
Instant
就会派上用场。
立即学习“Java免费学习笔记（深入）”；
这些类都是不可变（immutable）的，这意味着一旦创建，它们的值就不能被改变。所有修改日期时间的操作（比如加一天、减一小时）都会返回一个新的实例，这大大提升了代码的线程安全性，也避免了许多潜在的bug。这在多线程环境下简直是个福音，你再也不用担心某个线程不小心改了共享的日期对象而导致混乱。
import java.time.LocalDate; import java.time.LocalTime; import java.time.LocalDateTime; import java.time.ZoneId; import java.time.ZonedDateTime; import java.time.Instant; import java.time.format.DateTimeFormatter; import java.time.temporal.ChronoUnit; // 获取当前日期 LocalDate today = LocalDate.now(); System.out.println("今天: " + today); // 例如: 2023-10-26 // 获取当前时间 LocalTime nowTime = LocalTime.now(); System.out.println("现在时间: " + nowTime); // 例如: 15:30:45.123 // 获取当前日期时间 LocalDateTime nowDateTime = LocalDateTime.now(); System.out.println("当前日期时间: " + nowDateTime); // 例如: 2023-10-26T15:30:45.123 // 创建指定日期 LocalDate specificDate = LocalDate.of(2023, 1, 15); System.out.println("指定日期: " + specificDate); // 创建指定日期时间 LocalDateTime specificDateTime = LocalDateTime.of(2023, 10, 26, 10, 30, 0); System.out.println("指定日期时间: " + specificDateTime); // 加上几天/几小时 LocalDate nextWeek = today.plusWeeks(1); System.out.println("下周今天: " + nextWeek); LocalDateTime nextHour = nowDateTime.plusHours(1); System.out.println("一小时后: " + nextHour); // 减去几天/几小时 LocalDate yesterday = today.minusDays(1); System.out.println("昨天: " + yesterday); // 格式化日期时间 DateTimeFormatter formatter = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss"); String formattedDateTime = nowDateTime.format(formatter); System.out.println("格式化后的日期时间: " + formattedDateTime); // 例如: 2023年10月26日 15:30:45 // 解析字符串为日期时间 String dateString = "2024-05-20 13:14:00"; DateTimeFormatter parser = DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"); LocalDateTime parsedDateTime = LocalDateTime.parse(dateString, parser); System.out.println("解析后的日期时间: " + parsedDateTime); // 处理时区 ZonedDateTime zonedDateTime = ZonedDateTime.now(ZoneId.of("America/New_York")); System.out.println("纽约当前时间: " + zonedDateTime); // 时间戳 Instant Instant timestamp = Instant.now(); System.out.println("当前时间戳: " + timestamp.toEpochMilli()); // 毫秒级时间戳
为什么我们要拥抱java.time API？
说实话，Java早期处理日期时间的那一套，
java.util.Date
和
java.util.Calendar
，用起来真是让人头疼。我记得刚开始学Java那会儿，光是搞清楚
Date
的月份是从0开始，
Calendar
的星期是从1开始（而且周日是1），就够绕的了。更别提它们都是可变的，一个不小心，多线程环境下就可能出现数据错乱，调试起来简直是噩梦。而且，它们的API设计也比较混乱，很多操作都显得不那么直观。
java.time
的出现，彻底改变了这一切。它带来了几个核心的、革命性的改进：
首先是不可变性。所有的日期时间对象一旦创建，就不能被修改。任何对日期时间的“修改”操作，比如
plusDays()
或
minusHours()
，都会返回一个新的实例。这从根本上解决了多线程环境下日期时间对象共享的并发问题，代码也变得更易于理解和预测。你再也不用担心一个方法在不经意间改变了你传入的日期对象。
其次是清晰的语义。
LocalDate
、
LocalTime
、
LocalDateTime
、
ZonedDateTime
、
Instant
，它们的名字就直接告诉你它们代表什么。日期就是日期，时间就是时间，带时区的时间就是带时区的时间。这种明确的分离让开发者在选择合适的类时几乎不会犯错，也让代码的意图一目了然。
再来是流畅的API设计。链式调用变得非常自然，比如
LocalDate.now().plusDays(7).minusMonths(1)
，读起来就像一句自然语言，可读性极高。各种操作方法命名也都很直观，比如
isAfter()
、
isBefore()
、
isLeapYear()
等等。
最后，对时区处理的支持也做得非常完善。
ZoneId
和
ZonedDateTime
让时区转换和处理变得异常简单和安全，这对于开发国际化应用来说至关重要。以前用
Calendar
处理时区，那真是要了老命。
所以，拥抱
java.time
不仅仅是跟上潮流，更是为了让你的代码更健壮、更清晰、更易于维护。这玩意儿真是个救星。
日期时间的核心操作：创建、格式化与解析
光知道
java.time
好用还不够，我们得知道怎么把它用起来。最常用的操作无非就是创建日期时间对象、把它们显示成我们想要的格式（格式化），以及把字符串变成日期时间对象（解析）。
创建： 除了上面提到的
now()
（获取当前）和
of()
（指定值创建）之外，你还可以通过
parse()
方法从一个符合特定格式的字符串创建日期时间对象。
// 从字符串创建（默认ISO_LOCAL_DATE格式） LocalDate parsedLocalDate = LocalDate.parse("2023-11-01"); System.out.println("从字符串解析的日期: " + parsedLocalDate); // 从字符串创建（默认ISO_LOCAL_DATE_TIME格式） LocalDateTime parsedLocalDateTime = LocalDateTime.parse("2023-11-01T10:00:00"); System.out.println("从字符串解析的日期时间: " + parsedLocalDateTime);
需要注意的是，
parse()
方法在没有指定
DateTimeFormatter
时，会尝试使用ISO 8601标准格式进行解析。如果你的字符串格式不符合这个标准，那就得用到
DateTimeFormatter
了。
格式化： 这可是个高频操作。
java.time
通过
DateTimeFormatter
类提供了强大的格式化能力。你可以用预定义的格式，也可以自定义模式。
// 预定义格式 LocalDateTime current = LocalDateTime.now(); String basicIsoDate = current.format(DateTimeFormatter.BASIC_ISO_DATE); // 20231026 String isoLocalDateTime = current.format(DateTimeFormatter.ISO_LOCAL_DATE_TIME); // 2023-10-26T15:30:45.123 System.out.println("Basic ISO Date: " + basicIsoDate); System.out.println("ISO Local Date Time: " + isoLocalDateTime); // 自定义模式 DateTimeFormatter customFormatter = DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss EEEE", java.util.Locale.CHINA); String customFormatted = current.format(customFormatter); System.out.println("自定义格式: " + customFormatted); // 例如: 2023/10/26 15:30:45 星期四 // 注意Locale的使用，这对于国际化非常重要，比如星期几的显示
这里有个小细节，
ofPattern()
的第二个参数可以指定
Locale
，这决定了像“星期几”这样的文本输出是中文、英文还是其他语言，非常实用。
解析： 解析就是格式化的逆过程，把字符串变回日期时间对象。同样需要
DateTimeFormatter
来告诉解析器字符串的格式。
String dateStringForParse = "2025年01月01日 12:00:00"; DateTimeFormatter parserToUse = DateTimeFormatter.ofPattern("yyyy年MM月dd日 HH:mm:ss"); try { LocalDateTime parsedAgain = LocalDateTime.parse(dateStringForParse, parserToUse); System.out.println("再次解析的日期时间: " + parsedAgain); } catch (java.time.format.DateTimeParseException e) { System.err.println("日期字符串格式不匹配: " + e.getMessage()); // 这里可以处理解析失败的情况，比如给用户提示或者记录日志 }
解析时，字符串的格式必须和
DateTimeFormatter
定义的模式严格匹配，否则会抛出
DateTimeParseException
。这是个常见的坑，尤其是在处理用户输入或者外部数据时，务必做好异常处理。
处理时间差与周期：Duration与Period的妙用
在实际开发中，我们经常需要计算两个日期之间相隔多久，或者一个时间点过去/未来多少时间。
java.time
提供了
Duration
和
Period
这两个类来专门处理这类需求，它们各自侧重于不同的时间单位。
Duration
用于表示时间量，通常是秒或纳秒级别的时间差。它关注的是时间轴上的绝对长度，比如“3小时30分钟”。
import java.time.Duration; import java.time.Instant; import java.time.LocalDateTime; Instant startInstant = Instant.now(); // 模拟一些耗时操作 try { Thread.sleep(2500); // 暂停2.5秒 } catch (InterruptedException e) { Thread.currentThread().interrupt(); } Instant endInstant = Instant.now(); Duration timeElapsed = Duration.between(startInstant, endInstant); System.out.println("操作耗时 (秒): " + timeElapsed.getSeconds()); // 大约2秒 // 创建一个指定时长的Duration Duration threeHours = Duration.ofHours(3); LocalDateTime futureTime = LocalDateTime.now().plus(threeHours); System.out.println("三小时后: " + futureTime);
Duration
可以很好地用于计算代码执行时间、任务持续时间等场景。它提供了
toDays()
、
toHours()
、
toMinutes()
、
getSeconds()
等方法来获取不同单位的时间量。
Period
则用于表示日期量，也就是年、月、日为单位的时间段，比如“2年5个月零10天”。它关注的是日历上的概念，不受具体时间点的影响。
import java.time.Period; import java.time.LocalDate; LocalDate startDate = LocalDate.of(2022, 1, 15); LocalDate endDate = LocalDate.of(2023, 10, 26); Period period = Period.between(startDate, endDate); System.out.println("相隔年数: " + period.getYears()); // 1 System.out.println("相隔月数: " + period.getMonths()); // 9 System.out.println("相隔天数: " + period.getDays()); // 11 System.out.println("总共相隔: " + period.getYears() + "年" + period.getMonths() + "月" + period.getDays() + "天"); // 创建一个指定周期的Period Period oneYearTwoMonths = Period.ofYears(1).plusMonths(2); LocalDate futureDate = LocalDate.now().plus(oneYearTwoMonths); System.out.println("一年两个月后: " + futureDate);
Period
在计算年龄、租赁期限、贷款周期等场景下非常有用。它会智能地处理闰年和不同月份的天数差异。
一个常见的误区是混淆
Duration
和
Period
。如果你想知道两个
LocalDateTime
之间相差多少“小时”或“秒”，用
Duration
。如果你想知道两个
LocalDate
之间相差多少“年”、“月”、“日”，那就用
Period
。选择正确的工具，能让你的日期时间计算变得清晰且不易出错。
评论（已关闭）
评论已关闭