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(增加指定天数)等。

  1. 创建 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
      
  2. 获取日期信息:

    • 获取年份、月份、日期等:

      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
      
  3. 操作日期:

    • 增加或减少天数:

      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
      
  4. 比较日期:

    • 判断两个日期是否相等:

      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 之前)
      
  5. 格式化日期:

    • 将日期格式化为字符串:

      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 类的一些主要特点和常用方法:

  1. 创建 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
      
  2. 获取时间信息:

    • 获取小时、分钟、秒、毫秒等:

      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
      
  3. 操作时间:

    • 增加或减少小时数:

      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
      
  4. 比较时间:

    • 判断两个时间是否相等:

      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 之前)
      
  5. 格式化时间:

    • 将时间格式化为字符串:

      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 类的一些主要特点和常用方法:

  1. 创建 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
      
  2. 获取日期和时间信息:

    • 获取年、月、日、小时、分钟、秒等:

      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
      
  3. 操作日期和时间:

    • 增加或减少年、月、日、小时、分钟、秒等:

      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
      
  4. 比较日期和时间:

    • 判断两个日期时间是否相等:

      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 之前)
      
  5. 格式化日期时间:

    • 将日期时间格式化为字符串:

      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 类的一些主要特点和常用方法:

  1. 创建 Instant 对象:

    • 使用 now 方法获取当前的时间戳:

      Instant currentTimestamp = Instant.now();
      System.out.println(currentTimestamp);    // 输出:2024-01-18T08:30:00.123456789Z
      
    • 使用 ofEpochSecondofEpochMilli 方法创建指定的时间戳:

      Instant specificTimestamp = Instant.ofEpochSecond(1609459200);
      System.out.println(specificTimestamp);   // 输出:2021-01-01T00:00:00Z
      
  2. 获取时间戳信息:

    • 获取秒数和纳秒数:

      long seconds = specificTimestamp.getEpochSecond();
      int nanos = specificTimestamp.getNano();
      System.out.println(seconds);    // 输出:1609459200
      System.out.println(nanos);      // 输出:0
      
  3. 操作时间戳:

    • 增加或减少秒数或纳秒数:

      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
      
  4. 比较时间戳:

    • 判断两个时间戳是否相等:

      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 之前)
      
  5. 格式化时间戳:

    • 将时间戳格式化为字符串:

      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 类的一些主要特点和常用方法:

  1. 创建 Duration 对象:

    • 使用 ofSecondsofMillis 方法创建指定的持续时间:

      Duration duration = Duration.ofSeconds(60);
      System.out.println(duration);    // 输出:PT1M
      
      Duration duration = Duration.ofMillis(500);
      System.out.println(duration);    // 输出:PT0.5S
      
  2. 获取持续时间信息:

    • 获取持续时间的秒数和纳秒数:

      long seconds = duration.getSeconds();
      int nanos = duration.getNano();
      System.out.println(seconds);    // 输出:60
      System.out.println(nanos);      // 输出:0
      
  3. 操作持续时间:

    • 增加或减少秒数或纳秒数:

      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
      
  4. 比较持续时间:

    • 判断两个持续时间是否相等:

      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)
      
  5. 格式化持续时间:

    • 将持续时间格式化为字符串:

      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 类的一些主要特点和常用方法:

  1. 创建 Period 对象:

    • 使用 ofYearsofMonthsofDays 等方法创建指定的持续期间:

      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
      
  2. 获取持续期间信息:

    • 获取持续期间的年数、月数和天数:

      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
      
  3. 操作持续期间:

    • 增加或减少年数、月数和天数:

      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
      
  4. 比较持续期间:

    • 判断两个持续期间是否相等:

      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)
      
  5. 格式化持续期间:

    • 将持续期间格式化为字符串:

      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
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。