Time包常用类详解（Java）
Time包常用API
java.time 包是 Java 8 引入的日期和时间处理类库，用于替代旧的 Date 和 Calendar 类。它提供了更加直观、易用且线程安全的日期和时间处理方式。下面是对 java.time 包中的一些核心类和常用功能的详解：
常用的 java.time 包中的类包括：
1. LocalDate：用于表示日期，通常用于生日、纪念日等。
常用方法有 of（创建 LocalDate 实例）、parse（从字符串解析 LocalDate）、getYear（获取年份）、getMonthValue（获取月份）、getDayOfMonth（获取日期）、plusDays（增加指定天数）等。
-
创建
LocalDate对象：-
使用
now方法获取当前的日期：LocalDate currentDate = LocalDate.now(); System.out.println(currentDate); // 输出：2024-01-18 -
使用
of方法创建指定的日期：LocalDate specificDate = LocalDate.of(2022, 12, 31); System.out.println(specificDate); // 输出：2022-12-31 -
使用
parse方法从字符串解析出日期：LocalDate parsedDate = LocalDate.parse("2022-12-31"); System.out.println(parsedDate); // 输出：2022-12-31
-
-
获取日期信息：
-
获取年份、月份、日期等：
int year = specificDate.getYear(); int month = specificDate.getMonthValue(); int day = specificDate.getDayOfMonth(); System.out.println(year); // 输出：2022 System.out.println(month); // 输出：12 System.out.println(day); // 输出：31 -
获取星期几：
DayOfWeek dayOfWeek = specificDate.getDayOfWeek(); System.out.println(dayOfWeek); // 输出：SATURDAY
-
-
操作日期：
-
增加或减少天数：
LocalDate newDate = specificDate.plusDays(7); System.out.println(newDate); // 输出：2023-01-07 LocalDate newDate = specificDate.minusDays(7); System.out.println(newDate); // 输出：2022-12-24 -
增加或减少月份：
LocalDate newDate = specificDate.plusMonths(1); System.out.println(newDate); // 输出：2023-01-31 LocalDate newDate = specificDate.minusMonths(1); System.out.println(newDate); // 输出：2022-11-30 -
增加或减少年份：
LocalDate newDate = specificDate.plusYears(1); System.out.println(newDate); // 输出：2023-12-31 LocalDate newDate = specificDate.minusYears(1); System.out.println(newDate); // 输出：2021-12-31
-
-
比较日期：
-
判断两个日期是否相等：
LocalDate date1 = LocalDate.of(2022, 12, 31); LocalDate date2 = LocalDate.of(2022, 12, 31); boolean isEqual = date1.equals(date2); System.out.println(isEqual); // 输出：true -
比较两个日期的先后顺序：
LocalDate date1 = LocalDate.of(2022, 12, 31); LocalDate date2 = LocalDate.of(2023, 1, 1); int compareResult = date1.compareTo(date2); System.out.println(compareResult); // 输出：-1 (date1 在 date2 之前)
-
-
格式化日期：
-
将日期格式化为字符串：
LocalDate date = LocalDate.of(2022, 12, 31); String formattedDate = date.format(DateTimeFormatter.ofPattern("yyyy-MM-dd")); System.out.println(formattedDate); // 输出：2022-12-31
-
2. LocalTime：用于表示时间，通常用于某个事件发生的时间等。
常用方法有 of（创建 LocalTime 实例）、parse（从字符串解析 LocalTime）、getHour（获取小时）、getMinute（获取分钟）、getSecond（获取秒数）、plusHours（增加指定小时数）等。
以下是 LocalTime 类的一些主要特点和常用方法：
-
创建
LocalTime对象：-
使用
now方法获取当前时间：LocalTime currentTime = LocalTime.now(); System.out.println(currentTime); // 输出：08:30:00.123456789 -
使用
of方法创建指定的时间：LocalTime specificTime = LocalTime.of(12, 30, 0); System.out.println(specificTime); // 输出：12:30:00 -
使用
parse方法从字符串解析出时间：LocalTime parsedTime = LocalTime.parse("12:30:00"); System.out.println(parsedTime); // 输出：12:30:00
-
-
获取时间信息：
-
获取小时、分钟、秒、毫秒等：
int hour = specificTime.getHour(); int minute = specificTime.getMinute(); int second = specificTime.getSecond(); int nano = specificTime.getNano(); System.out.println(hour); // 输出：12 System.out.println(minute); // 输出：30 System.out.println(second); // 输出：0 System.out.println(nano); // 输出：0
-
-
操作时间：
-
增加或减少小时数：
LocalTime newTime = specificTime.plusHours(1); System.out.println(newTime); // 输出：13:30:00 LocalTime newTime = specificTime.minusHours(1); System.out.println(newTime); // 输出：11:30:00 -
增加或减少分钟数：
LocalTime newTime = specificTime.plusMinutes(15); System.out.println(newTime); // 输出：12:45:00 LocalTime newTime = specificTime.minusMinutes(15); System.out.println(newTime); // 输出：12:15:00 -
增加或减少秒数：
LocalTime newTime = specificTime.plusSeconds(30); System.out.println(newTime); // 输出：12:30:30 LocalTime newTime = specificTime.minusSeconds(30); System.out.println(newTime); // 输出：12:29:30 -
增加或减少毫秒数：
LocalTime newTime = specificTime.plusNanos(500000000); System.out.println(newTime); // 输出：12:30:00.500000000 LocalTime newTime = specificTime.minusNanos(500000000); System.out.println(newTime); // 输出：12:29:59.500000000
-
-
比较时间：
-
判断两个时间是否相等：
LocalTime time1 = LocalTime.of(12, 30, 0); LocalTime time2 = LocalTime.of(12, 30, 0); boolean isEqual = time1.equals(time2); System.out.println(isEqual); // 输出：true -
比较两个时间的先后顺序：
LocalTime time1 = LocalTime.of(12, 30, 0); LocalTime time2 = LocalTime.of(13, 30, 0); int compareResult = time1.compareTo(time2); System.out.println(compareResult); // 输出：-1 (time1 在 time2 之前)
-
-
格式化时间：
-
将时间格式化为字符串：
LocalTime time = LocalTime.of(12, 30, 0); String formattedTime = time.format(DateTimeFormatter.ofPattern("HH:mm:ss")); System.out.println(formattedTime); // 输出：12:30:00
-
以上是 LocalTime 类的一些常用方法和操作，你可以根据具体需求使用这些方法来处理时间。注意，LocalTime 是不可变对象，它的所有方法都返回一个新的 LocalTime 对象，不会修改原始对象。
3. LocalDateTime：用于表示日期和时间，通常用于记录某个事件的具体时间。
常用方法有 of（创建 LocalDateTime 实例）、parse（从字符串解析 LocalDateTime）、toLocalDate（获取日期部分）、toLocalTime（获取时间部分）、plusDays（增加指定天数）、withHour（设置小时）等。
LocalDateTime 是 Java 8 中引入的日期时间类，它结合了日期和时间，并且不包含时区信息。
以下是 LocalDateTime 类的一些主要特点和常用方法：
-
创建
LocalDateTime对象：-
使用
now方法获取当前日期时间：LocalDateTime currentDateTime = LocalDateTime.now(); System.out.println(currentDateTime); // 输出：2024-01-18T08:30:00.123456789 -
使用
of方法创建指定的日期时间：LocalDateTime specificDateTime = LocalDateTime.of(2024, 1, 1, 12, 30, 0); System.out.println(specificDateTime); // 输出：2024-01-01T12:30:00 -
使用
parse方法从字符串解析出日期时间：LocalDateTime parsedDateTime = LocalDateTime.parse("2024-01-01T12:30:00"); System.out.println(parsedDateTime); // 输出：2024-01-01T12:30:00
-
-
获取日期和时间信息：
-
获取年、月、日、小时、分钟、秒等：
int year = specificDateTime.getYear(); Month month = specificDateTime.getMonth(); int day = specificDateTime.getDayOfMonth(); int hour = specificDateTime.getHour(); int minute = specificDateTime.getMinute(); int second = specificDateTime.getSecond(); System.out.println(year); // 输出：2024 System.out.println(month); // 输出：JANUARY System.out.println(day); // 输出：1 System.out.println(hour); // 输出：12 System.out.println(minute); // 输出：30 System.out.println(second); // 输出：0
-
-
操作日期和时间：
-
增加或减少年、月、日、小时、分钟、秒等：
LocalDateTime newDateTime = specificDateTime.plusYears(1); System.out.println(newDateTime); // 输出：2025-01-01T12:30:00 LocalDateTime newDateTime = specificDateTime.minusDays(7); System.out.println(newDateTime); // 输出：2019-12-25T12:30:00 -
设置特定的年、月、日、小时、分钟、秒等：
LocalDateTime modifiedDateTime = specificDateTime.withYear(2025); System.out.println(modifiedDateTime); // 输出：2025-01-01T12:30:00 LocalDateTime modifiedDateTime = specificDateTime.withMonth(2); System.out.println(modifiedDateTime); // 输出：2024-02-01T12:30:00
-
-
比较日期和时间：
-
判断两个日期时间是否相等：
LocalDateTime dateTime1 = LocalDateTime.of(2024, 1, 1, 12, 30, 0); LocalDateTime dateTime2 = LocalDateTime.of(2024, 1, 1, 12, 30, 0); boolean isEqual = dateTime1.equals(dateTime2); System.out.println(isEqual); // 输出：true -
比较两个日期时间的先后顺序：
LocalDateTime dateTime1 = LocalDateTime.of(2024, 1, 1, 12, 30, 0); LocalDateTime dateTime2 = LocalDateTime.of(2024, 1, 2, 13, 30, 0); int compareResult = dateTime1.compareTo(dateTime2); System.out.println(compareResult); // 输出：-1 (dateTime1 在 dateTime2 之前)
-
-
格式化日期时间：
-
将日期时间格式化为字符串：
LocalDateTime dateTime = LocalDateTime.of(2024, 1, 1, 12, 30, 0); String formattedDateTime = dateTime.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")); System.out.println(formattedDateTime); // 输出：2024-01-01 12:30:00
-
注意，LocalDateTime 是不可变对象，它的所有方法都返回一个新的 LocalDateTime 对象，不会修改原始对象。
4. Instant：用于表示某个时间点的时间戳，通常用于记录事件的发生时间。
常用方法有 now（获取当前时间戳）、ofEpochSecond（从秒数创建 Instant 实例）、plusSeconds（增加指定秒数）、toEpochMilli（获取毫秒级时间戳）等。
与 LocalDateTime 不同，Instant 类是基于机器的时间，它不包含与时区相关的信息。
以下是 Instant 类的一些主要特点和常用方法：
-
创建
Instant对象：-
使用
now方法获取当前的时间戳：Instant currentTimestamp = Instant.now(); System.out.println(currentTimestamp); // 输出：2024-01-18T08:30:00.123456789Z -
使用
ofEpochSecond或ofEpochMilli方法创建指定的时间戳：Instant specificTimestamp = Instant.ofEpochSecond(1609459200); System.out.println(specificTimestamp); // 输出：2021-01-01T00:00:00Z
-
-
获取时间戳信息：
-
获取秒数和纳秒数：
long seconds = specificTimestamp.getEpochSecond(); int nanos = specificTimestamp.getNano(); System.out.println(seconds); // 输出：1609459200 System.out.println(nanos); // 输出：0
-
-
操作时间戳：
-
增加或减少秒数或纳秒数：
Instant newTimestamp = specificTimestamp.plusSeconds(60); System.out.println(newTimestamp); // 输出：2021-01-01T00:01:00Z Instant newTimestamp = specificTimestamp.minusNanos(500000000); System.out.println(newTimestamp); // 输出：2021-01-01T00:00:59.5Z -
设置特定的秒数和纳秒数：
Instant modifiedTimestamp = specificTimestamp.withEpochSecond(1609545600); System.out.println(modifiedTimestamp); // 输出：2021-01-02T00:00:00Z Instant modifiedTimestamp = specificTimestamp.withNano(500000000); System.out.println(modifiedTimestamp); // 输出：2021-01-01T00:00:00.5Z
-
-
比较时间戳：
-
判断两个时间戳是否相等：
Instant timestamp1 = Instant.ofEpochSecond(1609459200); Instant timestamp2 = Instant.ofEpochSecond(1609459200); boolean isEqual = timestamp1.equals(timestamp2); System.out.println(isEqual); // 输出：true -
比较两个时间戳的先后顺序：
Instant timestamp1 = Instant.ofEpochSecond(1609459200); Instant timestamp2 = Instant.ofEpochSecond(1609545600); int compareResult = timestamp1.compareTo(timestamp2); System.out.println(compareResult); // 输出：-1 (timestamp1 在 timestamp2 之前)
-
-
格式化时间戳：
-
将时间戳格式化为字符串：
Instant timestamp = Instant.ofEpochSecond(1609459200); String formattedTimestamp = timestamp.toString(); System.out.println(formattedTimestamp); // 输出：2021-01-01T00:00:00Z
-
以上是 Instant 类的一些常用方法和操作，你可以根据具体需求使用这些方法来处理时间戳。Instant 类也是不可变对象，它的所有方法都返回一个新的 Instant 对象，不会修改原始对象。
需要注意的是，由于 Instant 类是基于机器的时间，它与具体的时区无关。如果需要与时区相关的操作，可以使用 ZonedDateTime 类或者将 Instant 转换为 LocalDateTime 来进行操作。
5. Duration：用于表示一段时间的持续时间，通常用于计算时间间隔。
Duration 是 Java 8 新增的一个类，用于表示一段时间的持续时间。
它可以以秒和纳秒的形式表示时间间隔，提供了各种方法进行持续时间的计算和操作。
以下是 Duration 类的一些主要特点和常用方法：
-
创建
Duration对象：-
使用
ofSeconds或ofMillis方法创建指定的持续时间：Duration duration = Duration.ofSeconds(60); System.out.println(duration); // 输出：PT1M Duration duration = Duration.ofMillis(500); System.out.println(duration); // 输出：PT0.5S
-
-
获取持续时间信息：
-
获取持续时间的秒数和纳秒数：
long seconds = duration.getSeconds(); int nanos = duration.getNano(); System.out.println(seconds); // 输出：60 System.out.println(nanos); // 输出：0
-
-
操作持续时间：
-
增加或减少秒数或纳秒数：
Duration newDuration = duration.plusSeconds(30); System.out.println(newDuration); // 输出：PT1M30S Duration newDuration = duration.minusNanos(200000000); System.out.println(newDuration); // 输出：PT0.3999998S -
设置特定的秒数和纳秒数：
Duration modifiedDuration = duration.withSeconds(120); System.out.println(modifiedDuration); // 输出：PT2M Duration modifiedDuration = duration.withNanos(500000000); System.out.println(modifiedDuration); // 输出：PT0.5S
-
-
比较持续时间：
-
判断两个持续时间是否相等：
Duration duration1 = Duration.ofSeconds(60); Duration duration2 = Duration.ofSeconds(60); boolean isEqual = duration1.equals(duration2); System.out.println(isEqual); // 输出：true -
比较两个持续时间的先后顺序：
Duration duration1 = Duration.ofSeconds(60); Duration duration2 = Duration.ofSeconds(120); int compareResult = duration1.compareTo(duration2); System.out.println(compareResult); // 输出：-1 (duration1 小于 duration2)
-
-
格式化持续时间：
-
将持续时间格式化为字符串：
Duration duration = Duration.ofSeconds(60); String formattedDuration = duration.toString(); System.out.println(formattedDuration); // 输出：PT1M
-
以上是 Duration 类的一些常用方法和操作，你可以根据具体需求使用这些方法来处理持续时间。Duration 类也是不可变对象，它的所有方法都返回一个新的 Duration 对象，不会修改原始对象。
需要注意的是，Duration 类适用于处理秒和纳秒级别的时间间隔，如果需要处理年、月、日等更大的时间单位，可以使用 Period 类。
6. Period：用于表示一段日期的持续时间，以年、月、日为单位，通常用于计算生日距离今天的天数等。
常用方法有 between（计算两个日期之间的持续时间）、plusYears（增加指定年数）、getYears（获取年数部分）等。
它以年、月、日的形式表示时间段，提供了各种方法进行持续期间的计算和操作。
以下是 Period 类的一些主要特点和常用方法：
-
创建
Period对象：-
使用
ofYears、ofMonths、ofDays等方法创建指定的持续期间：Period period = Period.ofYears(1); System.out.println(period); // 输出：P1Y Period period = Period.ofMonths(6); System.out.println(period); // 输出：P6M Period period = Period.ofDays(30); System.out.println(period); // 输出：P30D
-
-
获取持续期间信息：
-
获取持续期间的年数、月数和天数：
int years = period.getYears(); int months = period.getMonths(); int days = period.getDays(); System.out.println(years); // 输出：1 System.out.println(months); // 输出：6 System.out.println(days); // 输出：30
-
-
操作持续期间：
-
增加或减少年数、月数和天数：
Period newPeriod = period.plusYears(1); System.out.println(newPeriod); // 输出：P2Y6M30D Period newPeriod = period.minusMonths(3); System.out.println(newPeriod); // 输出：P6M30D -
设置特定的年数、月数和天数：
Period modifiedPeriod = period.withYears(2); System.out.println(modifiedPeriod); // 输出：P2Y Period modifiedPeriod = period.withDays(15); System.out.println(modifiedPeriod); // 输出：P6M15D
-
-
比较持续期间：
-
判断两个持续期间是否相等：
Period period1 = Period.ofYears(1); Period period2 = Period.ofYears(1); boolean isEqual = period1.equals(period2); System.out.println(isEqual); // 输出：true -
比较两个持续期间的先后顺序：
Period period1 = Period.ofMonths(3); Period period2 = Period.ofMonths(6); int compareResult = period1.compareTo(period2); System.out.println(compareResult); // 输出：-1 (period1 小于 period2)
-
-
格式化持续期间：
-
将持续期间格式化为字符串：
Period period = Period.ofYears(1); String formattedPeriod = period.toString(); System.out.println(formattedPeriod); // 输出：P1Y
-
以上是 Period 类的一些常用方法和操作，你可以根据具体需求使用这些方法来处理持续期间。Period 类也是不可变对象，它的所有方法都返回一个新的 Period 对象，不会修改原始对象。
需要注意的是，Period 类适用于处理年、月、日等更大的时间单位，如果需要处理秒和纳秒级别的时间间隔，可以使用 Duration 类。