1、概述
java8在java.time包下重新实现了日期相关类。主要有LocalDate、LocalTime、LocalDateTime。每个类功能明确清晰、类之间协作简单、API 定义清晰、功能强大无需借助外部工具类，并且线程安全。
2、LocalDate
表示没有时区的日期，常用于不需要时间信息的日期操作，即年、月和日。常用于需要处理日期但不需要处理时间的场景。主要有以下常用方法：
2.1 创建LocalDate对象的方法
通过LocalDate类提供的静态方法来创建LocalDate对象
- 1)、public static LocalDate now()：根据当前日期（可以指定时区或时钟）获取LocalDate对象。
- 2)、public static LocalDate of(年, 月, 日)：根据指定日期获取LocalDate对象。
// 获取LocalDate对象的方法
// 1、LocalDate now()：根据当前日期
LocalDate now1 = LocalDate.now();
System.out.println(now1); // 输出2025-01-14
// 2、LocalDate now(ZoneId zone)：根据当前日期（指定时区）
LocalDate now2 = LocalDate.now(ZoneId.of("Asia/Shanghai"));
System.out.println(now2); // 输出2025-01-14
// 3、LocalDate now(Clock clock)：根据当前日期（指定时钟）
LocalDate now3 = LocalDate.now(Clock.systemDefaultZone());
System.out.println(now3); // 输出2025-01-14
// 4、LocalDate of(int year, int month, int dayOfMonth)：根据指定日期获取
LocalDate localDate = LocalDate.of(2025, 1, 1); // 指定日期 2023-01-01
System.out.println(localDate); // 输出2025-01-012.2 获取方法
通过调用LocalDate对象的方法来获取到该日期对象的对应值。
- 1)、public int getYear()：获取年份。
- 2)、public Month getMonth()：获取月份的枚举值，可以通过该枚举值的getValue()方法获取到具体的月份（1~12）。
- 3)、public int getMonthValue()：获取月份（1~12）。
- 4)、public int getDayOfYear()：获取当前日期在当年中是第几天（1~366）。
- 5)、public int getDayOfMonth()：获取当前日期在当月中是第几天（1~31）。
- 6)、public DayOfWeek getDayOfWeek()：获取当前日期在当前星期中的星期几的枚举值，可以通过该枚举值的getValue()方法获取到具体是星期几（1~7）。
- 7)、public int lengthOfYear()：当前年份的总天数。
- 8)、public int lengthOfMonth()：当前月份的总天数。
// 获取方法
LocalDate now = LocalDate.now();
System.out.println("当前日期：" + now); // 输出 当前日期：2025-01-14
// 1、int getYear()：获取年份
int year = now.getYear();
System.out.println("当前年份：" + year); // 输出 当前年份：2025
// 2、获取月份
// 1）Month getMonth()：获取月份枚举值
Month month = now.getMonth();
System.out.println("当前月份枚举值：" + month); // 输出 当前月份枚举值：JANUARY
System.out.println("当前月份枚举值的值：" + month.getValue()); // 输出 当前月份枚举值的值：1
// 2）int getMonthValue()：获取月份值（1-12）
int monthValue = now.getMonthValue();
System.out.println("当前月份值：" + monthValue); // 输出 当前月份值：1
// 3、获取天（日）值
// 1）、int getDayOfYear()：获取当前日期在当前年份中的第几天（1-366）
int dayOfYear = now.getDayOfYear();
System.out.println("当前年份中的第几天：" + dayOfYear); // 输出 当前年份中的第几天：14
// 2）、int getDayOfMonth()：获取当前日期在当前月份中的第几天（1-31）
int dayOfMonth = now.getDayOfMonth();
System.out.println("当前月份中的第几天：" + dayOfMonth); // 输出 当前月份中的第几天：14
// 3）、DayOfWeek getDayOfWeek()：获取当前日期在当前星期中的第几天
DayOfWeek dayOfWeek = now.getDayOfWeek();
System.out.println("当前星期中的星期几枚举值：" + dayOfWeek.getValue()); // 输出 当前星期中的星期几枚举值：2
System.out.println("当前星期中的星期几：" + dayOfWeek.getValue()); // 输出 当前星期中的星期几：2
// 4、int lengthOfYear()：获取当年的总天数
int lengthOfYear = now.lengthOfYear();
System.out.println("当前年份的总天数：" + lengthOfYear); // 输出 当前年份的总天数：365
// 5、int lengthOfMonth()：获取当月的总天数
int lengthOfMonth = now.lengthOfMonth();
System.out.println("当前月份的总天数：" + lengthOfMonth); // 输出 当前月份的总天数：312.3 运算方法
通过调用LocalDate对象的方法来对当前日期进行加减，返回一个新的LocalDate对象。
- 1)、public LocalDate plusDays(long daysToAdd)：当前日期加指定天数。
- 2)、public LocalDate minusDays(long daysToSubtract)：当前日期减指定天数。
- 3)、public LocalDate plusWeeks(long daysToAdd)：当前日期加指定周数。
- 4)、public LocalDate minusWeeks(long daysToAdd)：当前日期减指定周数。
- 5)、public LocalDate plusMonths(long daysToAdd)：当前日期加指定月数。
- 6)、public LocalDate minusMonths(long daysToAdd)：当前日期减指定月数。
- 7)、public LocalDate plusYears(long daysToAdd)：当前日期加指定年数。
- 8)、public LocalDate minusYears(long daysToAdd)：当前日期减指定年数。
// 运算方法
System.out.println("当前日期：" + now); // 输出 当前日期：2025-01-14
// 1、LocalDate plusDays(long daysToAdd)：当前日期加指定天数
LocalDate plusDays = now.plusDays(1);
System.out.println("当前日期加一天：" + plusDays); // 输出 当前日期加一天：2025-01-15
// 2、LocalDate minusDays(long daysToSubtract)：当前日期减指定天数
LocalDate minusDays = now.minusDays(1);
System.out.println("当前日期减一天：" + minusDays); // 输出 当前日期减一天：2025-01-13
// 3、LocalDate plusWeeks(long weeksToAdd)：当前日期加指定周数
LocalDate plusWeeks = now.plusWeeks(1);
System.out.println("当前日期加一周：" + plusWeeks); // 输出 当前日期加一周：2025-01-21
// 4、LocalDate minusWeeks(long weeksToSubtract)：当前日期减指定周数
LocalDate minusWeeks = now.minusWeeks(1);
System.out.println("当前日期减一周：" + minusWeeks); // 输出 当前日期减一周：2025-01-07
// 5、LocalDate plusMonths(long monthsToAdd)：当前日期加指定月数
LocalDate plusMonths = now.plusMonths(1);
System.out.println("当前日期加一月：" + plusMonths); // 输出 当前日期加一月：2025-02-14
// 6、LocalDate minusMonths(long monthsToSubtract)：当前日期减指定月数
LocalDate minusMonths = now.minusMonths(1);
System.out.println("当前日期减一月：" + minusMonths); // 输出 当前日期减一月：2024-12-14
// 7、LocalDate plusYears(long yearsToAdd)：当前日期加指定年数
LocalDate plusYears = now.plusYears(1);
System.out.println("当前日期加一年：" + plusYears); // 输出 当前日期加一年：2026-01-14
// 8、LocalDate minusYears(long yearsToSubtract)：当前日期加指定年数
LocalDate minusYears = now.minusYears(1);
System.out.println("当前日期加一年：" + minusYears); // 输出 当前日期加一年：2024-01-142.4 修改方法
通过调用LocalDate对象的方法来对当前日期的指定字段(年、月、日)进行修改，返回一个新的LocalDate对象。
- 1)、public LocalDate withYear(int year)：修改日期对象的年份。
- 2)、public LocalDate withMonth(int month)：修改日期对象的月份。
- 3)、public LocalDate withDayOfYear(int dayOfYear)：修改日期对象的日期（当前年份的第n天）。
- 4)、public LocalDate withDayOfMonth(int dayOfMonth)：修改日期对象的日期（当前月份的第n天）。
// 修改方法
System.out.println("当前日期：" + now); // 输出 当前日期：2025-01-14
// 1、LocalDate withYear(int year)：修改日期对象的年份
LocalDate withYear = now.withYear(2088);
System.out.println("修改日期对象的年份：" + withYear); // 输出 修改日期对象的年份：2088-01-14
// 2.LocalDate withMonth(int month)：修改日期对象的月份
LocalDate withMonth = now.withMonth(11);
System.out.println("修改日期对象的月份：" + withMonth); // 输出 修改日期对象的月份：2025-11-14
// 3.LocalDate withDayOfYear(int dayOfYear)：修改日期对象的日期（当前年份的第n天）
LocalDate withDayOfYear = now.withDayOfYear(1);
System.out.println("修改日期对象的日期为当前年份的第一天：" + withDayOfYear); // 输出 修改日期对象的日期为当前年份的第一天：2025-01-01
// 4、LocalDate withDayOfMonth(int dayOfMonth)：修改日期对象的日期（当前月份的第n天）
LocalDate withDayOfMonth = now.withDayOfMonth(1);
System.out.println("修改日期对象的日期为当前月份的第一天：" + withDayOfMonth); // 输出 修改日期对象的日期为当前月份的第一天：2025-01-012.5 比较方法
通过调用LocalDate对象的方法来将当前日期与指定日期进行比较，返回一个boolean值。
- 1)、public boolean isBefore(ChronoLocalDate other)：当前日期是否在指定日期之前。
- 2)、public boolean isAfter(ChronoLocalDate other)：当前日期是否在指定日期之后。
- 3)、public boolean isEqual(ChronoLocalDate other)：当前日期是否为指定日期。
- 4)、public boolean isLeapYear()：当前日期所在年份是否为闰年。
// 比较方法
System.out.println("当前日期：" + now); // 输出 当前日期：2025-01-14
LocalDate localDate1 = LocalDate.of(2024, 11, 11);
LocalDate localDate2 = LocalDate.of(2025, 2, 2);
// 1、指定日期是否在当前日期之前
boolean isBeforeLocalDate1 = now.isBefore(localDate1);
System.out.println("当前日期是否在2024-11-11之前：" + isBeforeLocalDate1); // 输出 当前日期是否在2024-11-11之前：false
boolean isBeforeLocalDate2 = now.isBefore(localDate2);
System.out.println("当前日期是否在2025-2-2之前：" + isBeforeLocalDate2); // 输出 当前日期是否在2025-2-2之前：true
// 2、指定日期是否在当前日期之后
boolean isAfterLocalDate1 = now.isAfter(localDate1);
System.out.println("当前日期是否在2024-11-11之后：" + isAfterLocalDate1); // 输出 当前日期是否在2024-11-11之后：true
boolean isAfterLocalDate2 = now.isAfter(localDate2);
System.out.println("当前日期是否在2025-2-2之后：" + isAfterLocalDate2); // 输出 当前日期是否在2025-2-2之后：false
// 3、指定日期是否为当前日期
boolean equalLocalDate1 = now.isEqual(localDate1);
System.out.println("当前日期是否为2024-11-11：" + equalLocalDate1); // 输出 当前日期是否为2024-11-11：false
boolean equalLocalDate = now.isEqual(LocalDate.of(2024, 12,12));
System.out.println("当前日期是否为2024-12-12：" + equalLocalDate); // 输出 当前日期是否为2024-12-12：false
// 4、当前日期所在年份是否为闰年
boolean leapYear = now.isLeapYear();
System.out.println("当前日期所在年份是否为闰年：" + leapYear); // 输出 当前日期所在年份是否为闰年：false
3、LocalTime
表示没有时区的时间，常用于不需要日期信息的时间操作，即小时、分钟、秒和纳秒。用于需要处理时间但不需要处理日期的场景。具体的方法与LocalDate大体相同。
3.1 创建LocalTime对象的方法
通过LocalTime类提供的静态方法进行获取。
- 1)、public static LocalTime.now()：根据当前时间（可以指定时区或时钟）获取LocalTime对象。
- 2)、public static LocalTime.of(时, 分, 秒)：根据指定时间获取LocalTime对象。
// 获取LocalTime对象的方法
// 1、LocalTime now()：根据当前时间
LocalTime now1 = LocalTime.now();
System.out.println(now1); // 输出 15:22:02.626103100
// 2、LocalTime now(ZoneId zone)：根据当前时间（指定时区）
LocalTime now2 = LocalTime.now(ZoneId.of("Asia/Shanghai"));
System.out.println(now2); // 输出 15:22:02.626103100
// 3、LocalTime now(Clock clock)：根据当前时间（指定时钟）
LocalTime now3 = LocalTime.now(Clock.systemDefaultZone());
System.out.println(now3); // 输出 15:22:02.626103100
// 4、LocalTime of(int hour, int minute, int second)：根据指定时间获取
LocalTime localTime = LocalTime.of(9, 9, 9);// 指定时间09:09:09
System.out.println(localTime); // 输出 09:09:093.2 获取方法
通过调用LocalDate对象的方法来获取到该时间对象的对应值。
- 1)、public int getHour()：获取当前时间的小时数。
- 2)、public int getMinute()：获取当前时间的分钟数。
- 3)、public int getSecond()：获取当前时间的秒数。
- 4)、public int getNano()：获取当前时间的纳秒数。
// 获取方法
System.out.println("当前时间：" + now); // 输出 当前时间：15:22:02.626103100
// 1、int getHour()：获取当前时间的小时数
int hour = now.getHour();
System.out.println("当前时间的小时数：" + hour); // 输出 当前时间的小时数：15
// 2、int getMinute()：获取当前时间的分钟数
int minute = now.getMinute();
System.out.println("当前时间的分钟数：" + minute); // 输出 当前时间的分钟数：22
// 3、int getSecond()：获取当前时间的秒数
int second = now.getSecond();
System.out.println("当前时间的秒数：" + second); // 输出 当前时间的秒数：2
// 4、int getNano()：获取当前时间的纳秒数
int nano = now.getNano();
System.out.println("当前时间的纳秒数：" + nano); // 输出 当前时间的纳秒数：6261031003.3 运算方法
通过调用LocalTime对象的方法来对当前时间进行加减，返回一个新的LocalTime对象。
- 1)、public LocalTime plusHours(long hoursToAdd)：当前时间加指定小时数。
- 2)、public LocalTime minusHours(long hoursToSubtract)：当前时间减指定小时数。
- 3)、public LocalTime plusMinutes(long minutesToAdd)：当前时间加指定分钟数。
- 4)、public LocalTime minusMinutes(long minutesToSubtract)：当前时间减指定分钟数。
- 5)、public LocalTime plusSeconds(long secondstoAdd)：当前时间加指定秒数。
- 6)、public LocalTime minusSeconds(long secondsToSubtract)：当前时间减指定秒数。
// 运算方法
System.out.println("当前时间：" + now); // 输出 当前时间：15:22:02.626103100
// 1、LocalTime plusHours(long hoursToAdd)：当前时间加指定小时数
LocalTime plusHours = now.plusHours(1);
System.out.println("当前时间加一小时：" + plusHours); // 输出 当前时间加一小时：16:22:02.626103100
// 2、LocalTime minusHours(long hoursToSubtract)：当前时间减指定小时数
LocalTime minusHours = now.minusHours(1);
System.out.println("当前时间减一小时：" + minusHours); // 输出 当前时间减一小时：14:22:02.626103100
// 3、LocalTime plusMinutes(long minutesToAdd)：当前时间加指定分钟数
LocalTime plusMinutes = now.plusMinutes(1);
System.out.println("当前时间加一分钟：" + plusMinutes); // 输出 当前时间加一分钟：15:23:02.626103100
// 4、LocalTime minusMinutes(long minutesToSubtract)：当前时间减指定分钟数
LocalTime minusMinutes = now.minusMinutes(1);
System.out.println("当前时间减一分钟：" + minusMinutes); // 输出 当前时间减一分钟：15:21:02.626103100
// 5、LocalTime plusSeconds(long secondstoAdd)：当前时间加指定秒数
LocalTime plusSeconds = now.plusSeconds(1);
System.out.println("当前时间加一秒钟：" + plusSeconds); // 输出 当前时间加一秒钟：15:22:03.626103100
// 6、LocalTime minusSeconds(long secondsToSubtract)：当前时间减指定秒数
LocalTime minusSeconds = now.minusSeconds(1);
System.out.println("当前时间减一秒钟：" + minusSeconds); // 输出 当前时间减一秒钟：15:22:01.6261031003.4 修改方法
通过调用LocalTime对象的方法来对当前时间的指定字段(时、分、秒)进行修改，返回一个新的LocalTime对象。
- 1)、public LocalTime withHour(int hour)：修改当前时间的小时数。
- 2)、public LocalTime withMinute(int minute)：修改当前时间的分钟数。
- 3)、public LocalTime withSecond(int second)：修改当前时间的秒数。
// 修改方法
System.out.println("当前时间：" + now); // 输出 当前时间：15:22:02.626103100
// 1、LocalTime withHour(int hour)：修改当前时间的小时数
LocalTime withHour = now.withHour(1);
System.out.println("将当前时间的小时数设置为1点：" + withHour); // 输出 将当前时间的小时数设置为1点：01:22:02.626103100
// 2、LocalTime withMinute(int minute)：修改当前时间的分钟数
LocalTime withMinute = now.withMinute(1);
System.out.println("将当前时间的分钟数设置为1分：" + withMinute); // 输出 将当前时间的分钟数设置为1分：15:01:02.626103100
// 3、LocalTime withSecond(int second)：修改当前时间的秒数
LocalTime withSecond = now.withSecond(1);
System.out.println("将当前时间的描述设置为1秒：" + withSecond); // 输出 将当前时间的描述设置为1秒：15:22:01.6261031003.5 比较方法
通过调用LocalTime对象的方法来将当前时间与指定时间进行比较。
- 1)、public int compareTo(LocalTime other)：将当前时间与指定时间进行比较，返回一个int值，如果>0则表示当前时间在指定时间之后，=0则表示是同一时间，<0则表示当前时间在指定时间之前。
- 2)、public boolean isBefore(LocalTime other)：当前时间是否在指定时间之前。
- 3)、public boolean isAfter(LocalTime other)：当前时间是否在指定时间之后。
// 比较方法
System.out.println("当前时间：" + now); // 当前时间：15:22:02.626103100
LocalTime time = LocalTime.of(11, 11, 11);
LocalTime time2 = LocalTime.of(22, 11, 11);
// 1、int compareTo(LocalTime other)：返回一个int值，该值=0则表示相等，>0表示在之后，<0表示在之前
int i1 = now.compareTo(time);
System.out.println("当前时间是否比11:11:11大：" + (i1 > 0)); // 输出 当前时间是否比11:11:11大：true
int i2 = now.compareTo(time2);
System.out.println("当前时间是否比22:11:11大：" + (i2 > 0)); // 输出 当前时间是否比22:11:11大：false
// 2、boolean isBefore(LocalTime other)：当前时间是否在指定时间之前
boolean isBeforeTime = now.isBefore(time);
System.out.println("当前时间是否在11:11:11之前：" + isBeforeTime); // 输出 当前时间是否在11:11:11之前：false
boolean isBeforeTime2 = now.isBefore(time2);
System.out.println("当前时间是否在22:11:11之前：" + isBeforeTime2); // 输出 当前时间是否在22:11:11之前：true
// 3、boolean isAfter(LocalTime other)：当前时间是否在指定时间之后
boolean isAfterTime = now.isAfter(time);
System.out.println("当前时间是否在11:11:11之后：" + isAfterTime); // 输出 当前时间是否在11:11:11之后：true
boolean isAfterTime2 = now.isAfter(time2);
System.out.println("当前时间是否在22:11:11之后：" + isAfterTime2); // 输出 当前时间是否在22:11:11之后：false
4、LocalDateTime
表示没有时区的日期和时间，常用于包含日期和时间的完整日期时间，即年、月、日、小时、分钟、秒和纳秒。常用于需要同时处理日期和时间的场景。主要有以下常用方法：
4.1 创建LocalDateTime对象的方法
通过LocalDateTime类提供的静态方法进行获取。
- 1)、public static LocalDateTime.now()：根据当前时间（可以指定时区或时钟）获取LocalDateTime对象。
- 2)、public static LocalDateTime.of(年, 月, 日, 时, 分, 秒)：根据指定日期时间获取LocalDateTime对象。
- 3)、public static LocalDateTime.of(LocalDate对象, LocalTime对象)：根据LocalDate和LocalTime对象来获取LocalDateTime对象。
// 获取LocalDateTime对象的方法
// 1、LocalDateTime now()：根据当前日期时间
LocalDateTime now1 = LocalDateTime.now();
System.out.println("当前日期时间：" + now1); // 输出 当前日期时间：2025-01-14T16:28:38.473278300
// 2、LocalDateTime now(ZoneId zone)：根据当前日期时间（指定时区）
LocalDateTime now2 = LocalDateTime.now(ZoneId.of("Asia/Shanghai"));
System.out.println("当前日期时间（指定时区为上海）：" + now2); // 输出 当前日期时间（指定时区为上海）：2025-01-14T16:28:38.489270300
// 3、LocalDateTime now(Clock clock)：根据当前日期时间（指定时钟）
LocalDateTime now3 = LocalDateTime.now(Clock.systemDefaultZone());
System.out.println("当前日期时间（指定时钟）：" + now3); // 输出 当前日期时间（指定时钟）：2025-01-14T16:28:38.490269800
// 4、LocalDateTime of(int year, int month, int dayOfMonth, int hour, int minute, int second)：根据指定日期时间获取
LocalDateTime localDateTime = LocalDateTime.of(2024, 9, 9,9, 9, 9); // 指定日期 2023-01-01
System.out.println("获取2024-9-9 09:09:09的日期时间对象：" + localDateTime); // 输出 获取2024-9-9 09:09:09的日期时间对象：2024-09-09T09:09:09
// 5、LocalDate of(int year, int month, int dayOfMonth)：根据LocalDate和LocalTime对象来获取
LocalDate localDate = LocalDate.of(2024, 10, 10);
LocalTime localTime = LocalTime.of(10, 10, 10);
LocalDateTime localDateTime1 = LocalDateTime.of(localDate, localTime);
System.out.println("根据LocalDate和LocalTime对象来获取：" + localDateTime1); // 输出 根据LocalDate和LocalTime对象来获取：2024-10-10T10:10:104.2 获取方法
通过调用LocalDateTime对象的方法来获取到该时间对象的对应值。具体的获取方法与LocalDate和LocalTime的获取方法相同。
// 获取方法
System.out.println("当前日期时间：" + now); // 输出 当前日期时间：2025-01-14T16:28:38.490269800
int year = now.getYear(); // 获取年份
int monthValue = now.getMonthValue(); // 获取月份值
int dayOfMonth = now.getDayOfMonth(); // 获取天
int hour = now.getHour(); // 获取小时
int minute = now.getMinute(); // 获取分钟
int second = now.getSecond(); // 获取秒钟
System.out.printf("%d年%d月%d日 %d:%d:%d\n", year, monthValue, dayOfMonth, hour, minute, second); // 输出 2025年1月14日 16:28:38
4.3 运算方法
通过调用LocalDateTime对象的方法来对当前日期时间进行加减，返回一个新的LocalDateTime对象。具体的获取方法与LocalDate和LocalTime的运算方法相同，可以通过链式调用的方法进行运算。
// 运算方法
System.out.println("当前时间：" + now); // 输出 当前时间：2025-01-14T16:28:38.490269800
LocalDateTime plusDateTime = now.plusYears(1).plusMonths(1).plusDays(1)
.plusHours(1).plusMinutes(1).plusSeconds(1);
System.out.println("当前时间加1年1月1日1时1分1秒：" + plusDateTime); // 输出 当前时间加1年1月1日1时1分1秒：2026-02-15T17:29:39.490269800
LocalDateTime minusDateTime = now.minusYears(1).minusMonths(1).minusDays(1)
.plusHours(1).minusMinutes(1).minusSeconds(1);
System.out.println("当前时间减1年1月1日1时1分1秒：" + minusDateTime); // 输出 当前时间减1年1月1日1时1分1秒：2023-12-13T17:27:37.490269800
4.4 修改方法
通过调用LocalDateTime对象的方法来对当前日期时间的指定字段(年、月、日、时、分、秒)进行修改，返回一个新的LocalDateTime对象。具体的获取方法与LocalDate和LocalTime的运算方法相同，可以通过链式调用的方法进行修改。
// 修改方法
System.out.println("当前时间：" + now); // 输出 当前时间：2025-01-14T16:28:38.490269800
LocalDateTime withDateTime = now.withYear(2025).withMonth(1).withDayOfMonth(1)
.withHour(1).withMinute(1).withSecond(1);
System.out.println("将当前时间的年设置为2025，月日时分秒属性都设置为1：" + withDateTime); // 输出 将当前时间的年设置为2025，月日时分秒属性都设置为1：2025-01-01T01:01:01.490269800
4.5 比较方法
通过调用LocalDateTime对象的方法来将当前日期时间与指定日期时间进行比较。
- 1)、public int compareTo(ChronoLocalDateTime<?> other)：将当前日期时间与指定日期时间进行比较，返回一个int值，如果>0则表示当前日期时间在指定日期时间之后，=0则表示是同一日期时间，<0则表示当前日期时间在指定日期时间之前。
- 2)、public boolean isBefore(ChronoLocalDateTime<?> other)：当前日期时间是否在指定时间之前。
- 3)、boolean isAfter(ChronoLocalDateTime<?> other)：当前日期时间是否在指定时间之后。
// 比较方法
System.out.println("当前时间：" + now); // 输出 当前时间：2025-01-14T16:28:38.490269800
LocalDateTime time = LocalDateTime.of(2024, 11, 11, 11, 11, 11);
LocalDateTime time2 = LocalDateTime.of(2025, 11, 11, 22, 11, 11);
// 1、int compareTo(ChronoLocalDateTime<?> other)：返回一个int值，该值=0则表示相等，>0表示在之后，<0表示在之前
int i1 = now.compareTo(time);
System.out.println("当前日期时间是否比2024-11-11 11:11:11大：" + (i1 > 0)); // 输出 当前日期时间是否比2024-11-11 11:11:11大：true
int i2 = now.compareTo(time2);
System.out.println("当前日期时间是否比2025-11-11 22:11:11大：" + (i2 > 0)); // 输出 当前日期时间是否比2025-11-11 22:11:11大：false
// 2、boolean isBefore(ChronoLocalDateTime<?> other)：当前日期时间是否在指定时间之前
boolean isBeforeTime = now.isBefore(time);
System.out.println("当前日期时间是否在2024-11-11 11:11:11之前：" + isBeforeTime); // 输出 当前日期时间是否在2024-11-11 11:11:11之前：false
boolean isBeforeTime2 = now.isBefore(time2);
System.out.println("当前日期时间是否在2025-11-11 22:11:11之前：" + isBeforeTime2); // 输出 当前日期时间是否在2025-11-11 22:11:11之前：true
// 3、boolean isAfter(ChronoLocalDateTime<?> other)：当前日期时间是否在指定时间之后
boolean isAfterTime = now.isAfter(time);
System.out.println("当前日期时间是否在2024-11-11 11:11:11之后：" + isAfterTime); // 输出 当前日期时间是否在2024-11-11 11:11:11之后：true
boolean isAfterTime2 = now.isAfter(time2);
System.out.println("当前日期时间是否在2025-11-11 22:11:11之后：" + isAfterTime2); // 输出 当前日期时间是否在2025-11-11 22:11:11之后：false
5、DateTimeFormatter
Java 8中用于格式化和解析日期时间的工具类。可以将日期和时间对象转化为指定格式的字符串，也可以将符合特定格式的字符串解析为日期和时间对象。专门用于格式化和解析LocalDate、LocalTime、LocalDateTime以及ZonedDateTime等日期和时间对象。
5.1 标准格式
5.1.1 预定义标准格式
| 标准格式 | 描述 | 示例 |
|---|---|---|
| ISO_LOCAL_DATE | ISO-8601标准的日期格式，仅包含日期部分 | 2023-04-01 |
| ISO_LOCAL_TIME | ISO-8601标准的时间格式，仅包含时间部分 | 12:30:45 |
| ISO_LOCAL_DATE_TIME | ISO-8601标准的日期-时间格式，包含日期和时间部分，中间用'T'分隔 | 2023-04-01T12:30:45 |
| ISO_OFFSET_DATE | ISO-8601标准的带时区偏移量的日期格式 | 2023-04-01+08:00 |
| ISO_OFFSET_TIME | ISO-8601标准的带时区偏移量的时间格式 | 12:30:45+08:00 |
| ISO_OFFSET_DATE_TIME | ISO-8601标准的带时区偏移量的日期-时间格式 | 2023-04-01T12:30:45+08:00 |
| ISO_ZONED_DATE_TIME | ISO-8601标准的带时区信息的日期-时间格式 | 2023-04-01T12:30:45+08:00[Asia/Shanghai] |
| ISO_INSTANT | ISO-8601标准的瞬时时间格式，通常用于表示时间戳 | 2023-04-01T12:30:45.123456789Z |
| ISO_ORDINAL_DATE | ISO-8601标准的序数日期格式，用年份和年内的天数表示 | 2023-100（表示2023年的第100天） |
| BASIC_ISO_DATE | ISO-8601标准的基本日期格式，使用数字分隔符'-'但无其他分隔符 | 20230401 |
| BASIC_ISO_TIME | ISO-8601标准的基本时间格式，使用数字分隔符':'但无其他分隔符 | 123045 |
| BASIC_ISO_DATE_TIME | ISO-8601标准的基本日期-时间格式，使用数字分隔符'-'和':'但无其他分隔符 | 20230401123045 |
| BASIC_ISO_OFFSET_DATE | ISO-8601标准的基本带时区偏移量的日期格式 | 20230401+0800 |
| BASIC_ISO_OFFSET_TIME | ISO-8601标准的基本带时区偏移量的时间格式 | 123045+0800 |
| BASIC_ISO_OFFSET_DATE_TIME | ISO-8601标准的基本带时区偏移量的日期-时间格式 | 20230401123045+0800 |
5.1.2 基本使用
LocalDateTime now = LocalDateTime.now();
System.out.println("当前时间：" + now); // 输出 当前时间：2025-01-14T17:29:15.277818800
// 标准格式
String basicIsoDateStr = now.format(DateTimeFormatter.BASIC_ISO_DATE);
System.out.println("BASIC_ISO_DATE（yyyyMMdd）格式：");
System.out.println(basicIsoDateStr); // 输出 20250114
String isoLocalDateStr = now.format(DateTimeFormatter.ISO_LOCAL_DATE);
System.out.println("ISO_LOCAL_DATE（yyyy-MM-dd）格式：");
System.out.println(isoLocalDateStr); // 输出 2025-01-14
String isoLocalTimeStr = now.format(DateTimeFormatter.ISO_LOCAL_TIME);
System.out.println("ISO_LOCAL_TIME（HH:mm:ss）格式：");
System.out.println(isoLocalTimeStr); // 输出 17:29:15.2778188
String isoLocalDateTimeStr = now.format(DateTimeFormatter.ISO_LOCAL_DATE_TIME);
System.out.println("ISO_LOCAL_DATE_TIME（yyyy-MM-ddTHH:mm:ss）格式：");
System.out.println(isoLocalDateTimeStr); // 输出 2025-01-14T17:29:15.27781885.2 自定义格式
使用DateTimeFormatter.ofPattern()自定义日期时间格式化类型，再通过时间时间类的格式化format()与解析方法parse()进行使用。
5.2.1 格式化
public String format(DateTimeFormatter formatter)：将日期时间对象格式化成自定格式的字符串。
// 1、格式化
LocalDateTime now = LocalDateTime.now();
System.out.println("当前时间：" + now); // 输出 当前时间：2025-01-14T17:58:31.977283800
String ofPatternFormat1 = now.format(DateTimeFormatter.ofPattern("yyyy年MM月dd日HH时mm分ss秒"));
System.out.println("自定义格式（yyyy年MM月dd日HH时mm分ss秒）格式化：");
System.out.println(ofPatternFormat1); // 输出2025年01月14日17时58分31秒
String ofPatternFormat2 = now.format(DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss"));
System.out.println("自定义格式（yyyy/MM/dd HH:mm:ss）格式化：");
System.out.println(ofPatternFormat2); // 输出2025/01/14 17:58:315.2.2 解析
通过日期时间类的静态方法parse(CharSequence text, DateTimeFormatter formatter)来将字符串解析成对应的日期时间对象
// 2、解析
LocalDateTime now = LocalDateTime.now();
System.out.println("当前时间：" + now); // 输出 当前时间：2025-01-14T17:58:31.977283800
LocalDateTime parse1 = LocalDateTime.parse(ofPatternFormat1, DateTimeFormatter.ofPattern("yyyy年MM月dd日HH时mm分ss秒"));
System.out.println("自定义格式（yyyy年MM月dd日HH时mm分ss秒）解析：");
System.out.println(parse1); // 输出2025-01-14T17:58:31
LocalDateTime parse2 = LocalDateTime.parse(ofPatternFormat2, DateTimeFormatter.ofPattern("yyyy/MM/dd HH:mm:ss"));
System.out.println("自定义格式（yyyy/MM/dd HH:mm:ss）解析：");
System.out.println(parse2); // 输出2025-01-14T17:58:31DateTimeFormatter是不可变的和线程安全的，可以被多个线程共享。在实际应用中，建议创建一个DateTimeFormatter实例并在整个应用中复用，而不是每次需要格式化或解析时都创建一个新的实例。
6、类型转换
6.1 日期时间类与String的相互转换
通过对象.format()转换为String，通过日期(时间、日期时间)类.parse()转换为日期(时间、日期时间)对象。
6.1.1 LocalDate与String相互转换
- 1)、LocalDate → String：LocalDate对象.format(DateTimeFormatter.ofPattern("要转换的格式"))；
- 2)、String → LocalDate：LocalDate.parse(要转换的String, DateTimeFormatter.ofPattern("要转换的格式"))；
// 与字符串相互转换
// 1)、LocalDate → String：LocalDate对象.format(DateTimeFormatter.ofPattern("要转换的格式"))；
LocalDate nowLocalDate = LocalDate.now();
String format = nowLocalDate.format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));
System.out.println("LocalDate转String：" + format); // 输出 LocalDate转String：2025-01-14
// 2)、String → LocalDate：LocalDate.parse(要转换的String, DateTimeFormatter.ofPattern("要转换的格式"))；
String nowLocalDateStr = "2024/12/13";
LocalDate parse = LocalDate.parse(nowLocalDateStr, DateTimeFormatter.ofPattern("yyyy/MM/dd"));
System.out.println("String转LocalDate：" + parse); // 输出 String转LocalDate：2024-12-136.1.2 LocalTime与String相互转换
- 1)、LocalTime → String：LocalTime对象.format(DateTimeFormatter.ofPattern("要转换的格式"))；
- 2)、String → LocalTime：LocalTime.parse(要转换的String, DateTimeFormatter.ofPattern("要转换的格式"))；
// 与字符串相互转换
// 1）、LocalTime→String：LocalDate对象.format(DateTimeFormatter.ofPattern("要转换的格式"))；
LocalTime nowLocalTime = LocalTime.now();
String format = nowLocalTime.format(DateTimeFormatter.ofPattern("HH:mm:ss"));
System.out.println("LocalTime转String：" + format); // 输出 LocalTime转String：18:11:45
// 2）、String→LocalTime：LocalDate.parse(要转换的String, DateTimeFormatter.ofPattern("要转换的格式"))；
String nowLocalTimeStr = "09:09:09";
LocalTime parse = LocalTime.parse(nowLocalTimeStr, DateTimeFormatter.ofPattern("HH:mm:ss"));
System.out.println("String转LocalTime：" + parse); // 输出 String转LocalTime：09:09:096.1.3 LocalDateTime与String相互转换
- 1)、LocalDateTime → String：LocalDateTime对象.format(DateTimeFormatter.ofPattern("要转换的格式"))；
- 2)、String → LocalDateTime：LocalDateTime.parse(要转换的String, DateTimeFormatter.ofPattern("要转换的格式"))；
// 与字符串相互转换
// 1)、LocalDateTime→String：LocalDateTime对象.format(DateTimeFormatter.ofPattern("要转换的格式"))；
LocalDateTime nowLocalDateTime = LocalDateTime.now();
String format = nowLocalDateTime.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss"));
System.out.println("LocalDateTime转String：" + format); // 输出 LocalDateTime转String：2025-01-14 18:16:15
// 2)、String→LocalDateTime：LocalDateTime.parse(要转换的String, DateTimeFormatter.ofPattern("要转换的格式"))；
String nowLocalTimeStr = "2024/09/09 09.09.09";
LocalDateTime parse = LocalDateTime.parse(nowLocalTimeStr, DateTimeFormatter.ofPattern("yyyy/MM/dd HH.mm.ss"));
System.out.println("String转LocalDateTime：" + parse); // 输出 String转LocalDateTime：2024-09-09T09:09:096.2 LocalDateTime与LocalDate、LocalTime的相互转换
6.2.1 LocalDateTime与LocalDate相互转换
- 1)、LocalDateTime → LocalDate：通过LocalDateTime对象.toLocalDate()方法提取LocalDate。
- 2)、LocalDate → LocalDateTime：通过atStartOfDay()或atTime()方法进行转换。
// LocalDateTime与LocalDate相互转换
// 1、LocalDateTime→LocalDate：通过LocalDateTime对象.toLocalDate()方法提取LocalDate
LocalDateTime now= LocalDateTime.now();
LocalDate localDateNow = now.toLocalDate();
System.out.println("LocalDateTime转LocalDate：");
System.out.println(localDateNow); // 输出2025-01-14
// 2、LocalDate→LocalDateTime：通过atStartOfDay()或atTime()方法进行转换。
// 1)、通过atStartOfDay()转换，时间设置为0点整
LocalDate localDateNow1 = LocalDate.now();
LocalDateTime localDateTimeNow1 = localDateNow1.atStartOfDay();
System.out.println("LocalDate转LocalDateTime（时间部分设置为0点整）：");
System.out.println(localDateTimeNow1); // 输出2025-01-14T00:00
// 2)、通过atTime()方法转换：有两种方式
LocalDate localDateNow2 = LocalDate.now();
// Ⅰ、结合LocalTime进行转转
LocalDateTime localDateTimeNow2 = localDateNow2.atTime(LocalTime.now());
System.out.println("LocalDate转LocalDateTime（结合LocalTime对象）：");
System.out.println(localDateTimeNow2); // 输出2025-01-14T18:30:45.509399400
// Ⅱ、自定义时间部分的方式进行转换
LocalDateTime localDateTimeNow3 = localDateNow2.atTime(12, 12, 12);
System.out.println("LocalDate转LocalDateTime（自定义时间部分）：");
System.out.println(localDateTimeNow3); // 输出2025-01-14T12:12:126.2.2 LocalDateTime与LocalTime相互转换
- 1)、LocalDateTime → LocalTime：通过LocalDateTime对象.toLocalTime()方法提取LocalTime。
- 2)、LocalTime→ LocalDateTime：通过atDate()方法进行转换。
// LocalDateTime与LocalTime相互转换
// 1)、LocalDateTime → LocalTime：通过LocalDateTime对象.toLocalTime()方法提取LocalTime。
LocalDateTime now = LocalDateTime.now();
LocalTime localTimeNow = now.toLocalTime();
System.out.println("LocalDateTime转LocalTime：");
System.out.println(localTimeNow); // 输出 18:42:37.913955300
// 2）、LocalTime→ LocalDateTime：通过atDate()方法进行转换。
LocalTime localTimeNow1 = LocalTime.now();
LocalDateTime localDateTime = localTimeNow1.atDate(LocalDate.now());
System.out.println("LocalTime转LocalDateTime（自定义日期）：");
System.out.println(localDateTime); // 输出 2025-01-14T18:42:37.913955300