现代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。选择正确的工具，能让你的日期时间计算变得清晰且不易出错。
