Time包常用类详解（Java）

发布时间：2024年01月19日

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 类。

文章来源:https://blog.csdn.net/weixin_48935611/article/details/135673837
本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若内容造成侵权/违法违规/事实不符，请联系我的编程经验分享网邮箱：chenni525@qq.com进行投诉反馈，一经查实，立即删除！

Time包常用类详解（Java）

Time包常用API

1. LocalDate：用于表示日期，通常用于生日、纪念日等。

2. LocalTime：用于表示时间，通常用于某个事件发生的时间等。

3. LocalDateTime：用于表示日期和时间，通常用于记录某个事件的具体时间。

4. Instant：用于表示某个时间点的时间戳，通常用于记录事件的发生时间。