深入了解Java 8 新特性-日期时间AP之LocalTime类

原创 凡夫贩夫 凡夫贬夫 2024-02-03 07:55 发表于河南

凡夫贬夫

CSDN博客专家、高级Java开发工程师，专注Java技术干货分享，如果对我感兴趣，那就关注我吧！

111篇原创内容

公众号

注意

本文编写的单元测试是基于java11，具体的版本号是：11.0.19

关于LocalTime

Java 8引入了一个非常重要的，用于处理时间的类：LocalTime。LocalTime可以表示一天中的时间，不包括日期信息。它提供了各种方法来处理时间，例如获取当前时间、设置时间、获取小时、分钟、秒等。

LocalTime的核心方法

LocalTime#now

LocalTime.now() 是用于获取当前本地时间的函数。它属于 java.time.LocalTime 类。这个方法不需要任何参数，当调用时，它会返回一个 LocalTime 对象，该对象表示当前的本地时间。

@Testpublic void test() {    LocalTime localTime = LocalTime.now();    System.out.println(localTime);}

LocalTime#of

在Java 11中，LocalTime.of()方法用于创建一个表示本地时间的LocalTime对象。这个方法接受一组时、分、秒和纳秒参数，并返回一个表示该时间的LocalTime对象。

参数说明：

• hour：表示小时的整数，范围从0到23。

• minute：表示分钟的整数，范围从0到59。

• second：表示秒的整数，范围从0到59。

• nanoOfSecond：表示纳秒的整数，范围从0到999999999。

@Testpublic void test2() {    LocalTime localTime = LocalTime.of(10, 20);    System.out.println(localTime);//输出结果：10:20    LocalTime localTime1 = LocalTime.of(11, 12, 59);    System.out.println(localTime1);//输出结果：11:12:59    LocalTime localTime2 = LocalTime.of(13, 12, 59, 59);    System.out.println(localTime2);//输出结果：13:12:59.000000059}

LocalTime#ofInstant、LocalTime#ofSecondOfDay、LocalTime#ofNanoOfDay

LocalTime 类提供了几个静态方法来创建 LocalTime 实例，其中包括 ofInstant(), ofSecondOfDay(), 和 ofNanoOfDay()。这些方法的功能和作用如下：

• LocalTime#ofInstant(Instant instant, ZoneId zone)：此方法接受一个 Instant 对象和一个 ZoneId 对象作为参数，并返回一个表示该瞬间的本地时间。Instant 是时间戳的一种表示形式，它表示自1970年1月1日00:00:00 UTC以来的秒数和纳秒数。ZoneId 是一个时区标识符，用于确定特定的时区。

• LocalTime#ofSecondOfDay(long secondOfDay)：此方法接受一个长整型数值作为参数，该值表示从当天的开始到指定时间的秒数。这个方法的目的是创建表示特定秒数的一天中的时间。

• LocalTime#ofNanoOfDay(long nanoOfDay)：此方法接受一个长整型数值作为参数，该值表示从当天的开始到指定时间的纳秒数。这个方法的目的是创建表示特定纳秒数的一天中的时间。

这三个方法提供了一种灵活的方式来创建 LocalTime 实例，可以根据你的需求选择使用哪种方式。

@Testpublic void test3() {    LocalTime localTime = LocalTime.ofInstant(Instant.now(), ZoneId.systemDefault());    System.out.println(localTime);    LocalTime localTime1 = LocalTime.ofNanoOfDay(1000000000L);    System.out.println(localTime1);//00:00:01    LocalTime localTime2 = LocalTime.ofSecondOfDay(10L);    System.out.println(localTime2);//输出结果：00:00:10}

LocalTime#from

LocalTime.from() 方法用于从给定的时间戳（long）或Instant对象创建一个LocalTime实例。需要注意的是，这些方法在创建LocalTime实例时，将忽略时区信息。LocalTime表示的是没有时区的本地时间。如果你需要具有时区的准确时间，请考虑使用ZonedDateTime类。

@Testpublic void test4() {    LocalDateTime localDateTime = LocalDateTime.of(2023, 12, 11, 18, 59, 59);    LocalTime from = LocalTime.from(localDateTime);    System.out.println(from);//输出结果：18:59:59}

LocalTime#parse

LocalTime.parse()方法是用于将字符串解析为LocalTime对象的方法。该方法接受一个字符串作为参数，并尝试将其解析为时间，返回一个表示该时间的LocalTime对象。使用LocalTime.parse()方法时，需要确保传递给该方法的字符串符合24小时制的时间格式，即小时、分钟和秒的顺序。如果字符串的格式不符合要求，将会抛出DateTimeParseException异常。

@Testpublic void test5() {    LocalTime parse = LocalTime.parse("23:59:59");    LocalTime parse1 = LocalTime.parse("21:58:59", DateTimeFormatter.ISO_TIME);    System.out.println(parse);    System.out.println(parse1);}

LocalTime#isSupported

LocalTime#isSupported()用于检查LocalTime类是否支持指定的字段。这意味着，通过使用此方法，我们可以检查是否可以针对指定的字段进行此LocalTime的查询。如果LocalTime类支持某个字段，那么就可以使用这个字段进行时间的查询和操作。如果LocalTime类不支持某个字段，那么调用与该字段相关的查询和操作方法将会抛出异常。

@Testpublic void test6() {    LocalTime now = LocalTime.now();    boolean supported = now.isSupported(ChronoUnit.HOURS);    boolean supported1 = now.isSupported(ChronoUnit.YEARS);    System.out.println(supported);    System.out.println(supported1);}

LocalTime#range

LocalTime类的range()用于返回一个表示时间范围内的LocalTime对象范围。该方法接受一个LocalTime对象作为参数，并返回一个包含该时间点之前和之后时间的范围。

@Testpublic void test7() {    LocalTime now = LocalTime.now();    ValueRange range = now.range(ChronoField.HOUR_OF_DAY);    System.out.println(range.getMaximum());//输出结果：23    System.out.println(range.getMinimum());//输出结果：0    ValueRange range1 = now.range(ChronoField.MINUTE_OF_HOUR);    System.out.println(range1.getMaximum());//输出结果：59    System.out.println(range1.getMinimum());//输出结果：0}

LocalTime#get、LocalTime#getLong、LocalTime#getHour、LocalTime#getMinute、LocalTime#getSecond

LocalTime类中的get、getLong、getHour、getMinute和getSecond方法用于获取LocalTime对象中的时间部分。

• get(TemporalField field)方法：该方法用于获取LocalTime对象中指定的时间字段。TemporalField是一个接口，它定义了时间的各种字段，如小时、分钟、秒等。

• getLong(TemporalField field)方法：这个方法与get方法类似，但返回的是长整型值，而不是整型值。

• getHour()方法：该方法用于获取LocalTime对象中的小时数。

• getMinute()方法：该方法用于获取LocalTime对象中的分钟数。

• getSecond()方法：该方法用于获取LocalTime对象中的秒数。

@Testpublic void test8() {    LocalTime localTime = LocalTime.of(15, 59, 59);    int hour = localTime.get(ChronoField.HOUR_OF_DAY);    int minute = localTime.get(ChronoField.MINUTE_OF_HOUR);    int second = localTime.get(ChronoField.SECOND_OF_MINUTE);    System.out.println(hour + "," + minute + "," + second);    int hour1 = localTime.getHour();    int minute1 = localTime.getMinute();    int second1 = localTime.getSecond();    System.out.println(hour1 + "," + minute1 + "," + second1);}

LocalTime#with、LocalTime#withHour、LocalTime#withMinute、LocalTime#withSecond

LocalTime类中的with、withHour、withMinute和withSecond方法用于修改和创建新的LocalTime实例，这些方法提供了一种方便的方式来创建和修改本地时间实例的各个字段。它们不会改变原始的LocalTime实例，而是返回一个新的实例。

• LocalTime.with(TemporalField, long)：这个方法根据给定的时间字段和值，返回一个新的本地时间实例。这个方法可以用于修改小时、分钟、秒以及纳秒等字段。例如，LocalTime.now().with(ChronoField.HOUR_OF_DAY, 10)将返回一个新的本地时间，该时间的小时字段为10。

• LocalTime.withHour(int hour)：这个方法返回一个新的本地时间实例，该实例的小时字段与给定的小时字段相匹配。例如，LocalTime.now().withHour(10)将返回一个新的本地时间，该时间的小时字段为10。

• LocalTime.withMinute(int minute)：这个方法返回一个新的本地时间实例，该实例的分钟字段与给定的分钟字段相匹配。例如，LocalTime.now().withMinute(30)将返回一个新的本地时间，该时间的分钟字段为30。

• LocalTime.withSecond(int second)：这个方法返回一个新的本地时间实例，该实例的秒字段与给定的秒字段相匹配。例如，LocalTime.now().withSecond(45)将返回一个新的本地时间，该时间的秒字段为45。

@Testpublic void test9() {    LocalTime localTime = LocalTime.of(15, 59, 59);    TemporalAdjuster temporalAdjuster = item -> item.plus(1, ChronoUnit.HOURS);//调节器逻辑：加1小时    LocalTime result = localTime.with(temporalAdjuster);//执行一个时间调节器的调节逻辑    System.out.println(result);//输出结果：16:59:59    LocalTime localTime1 = localTime.withHour(2);//指定hh::mm的hh部分为2    System.out.println(localTime1);//输出结果：02:59:59    LocalTime localTime2 = localTime.withMinute(2);//指定hh::mm的mm部分为2    System.out.println(localTime2);//输出结果：15:02:59    LocalTime localTime3 = localTime.withSecond(1);    System.out.println(localTime3);//输出结果：15:59:01}

LocalTime#truncatedTo

LocalTime.truncatedTo()方法用于将当前时间截断到指定的时间单位。它接受一个DurationUnit参数，该参数表示要截断的时间单位，例如分钟、小时、天等。需要注意的是，截断操作不会改变原始的LocalTime实例，而是返回一个新的实例。

@Testpublic void test10() {    LocalTime localTime = LocalTime.of(10, 31, 59, 1);    LocalTime localTime1 = localTime.truncatedTo(ChronoUnit.HOURS);    LocalTime localTime2 = localTime.truncatedTo(ChronoUnit.MINUTES);    LocalTime localTime3 = localTime.truncatedTo(ChronoUnit.SECONDS);    System.out.println(localTime1);//输出结果：10:00    System.out.println(localTime2);//输出结果：10:31    System.out.println(localTime3);//输出结果：10:31:59}

LocalTime#plus、LocalTime#plusHours、LocalTime#plusMinutes、LocalTime#plusSeconds

LocalTime类中的plus、plusHours、plusMinutes和plusSeconds方法用于在现有的LocalTime实例上添加指定的时间量，它们返回一个新的本地时间实例，而不是修改原始的实例。

• LocalTime.plus(Duration amountToAdd)：这个方法接受一个Duration对象作为参数，该对象表示要添加的时间量。这个方法返回一个新的本地时间实例，该实例在现有的时间上添加了指定的时间量。例如，LocalTime.now().plus(Duration.ofHours(2))将在现有的本地时间上添加两个小时，并返回一个新的本地时间实例。

• LocalTime.plusHours(long hoursToAdd)：这个方法接受一个长整型数值作为参数，表示要添加的小时数。这个方法返回一个新的本地时间实例，该实例在现有的时间上添加了指定的小时数。例如，LocalTime.now().plusHours(2)将在现有的本地时间上添加两个小时，并返回一个新的本地时间实例。

• LocalTime.plusMinutes(long minutesToAdd)：这个方法接受一个长整型数值作为参数，表示要添加的分钟数。这个方法返回一个新的本地时间实例，该实例在现有的时间上添加了指定的分钟数。例如，LocalTime.now().plusMinutes(30)将在现有的本地时间上添加30分钟，并返回一个新的本地时间实例。

• LocalTime.plusSeconds(long secondsToAdd)：这个方法接受一个长整型数值作为参数，表示要添加的秒数。这个方法返回一个新的本地时间实例，该实例在现有的时间上添加了指定的秒数。例如，LocalTime.now().plusSeconds(45)将在现有的本地时间上添加45秒，并返回一个新的本地时间实例。

@Testpublic void test11() {    LocalTime localTime = LocalTime.of(10, 12, 19);    LocalTime localTime1 = localTime.plus(1, ChronoUnit.HOURS);    System.out.println(localTime1);//输出结果：11:12:19    LocalTime localTime4 = localTime.plusHours(1);    System.out.println(localTime.equals(localTime4));//输出结果：true    LocalTime localTime2 = localTime.plus(1, ChronoUnit.MINUTES);    System.out.println(localTime2);//输出结果：10:13:19    LocalTime localTime5 = localTime.plusMinutes(1);    System.out.println(localTime2.equals(localTime5));//输出结果为：true    LocalTime localTime3 = localTime.plus(1, ChronoUnit.SECONDS);    System.out.println(localTime3);//输出结果：10:12:20    LocalTime localTime6 = localTime.plusSeconds(1);    System.out.println(localTime3.equals(localTime6));//输出结果：true}

LocalTime#minus、LocalTime#minusHours、LocalTime#minusMinutes、LocalTime#minusSeconds

LocalTime类中的minus、minusHours、minusMinutes和minusSeconds方法用于从当前时间减去指定的时间量。它们不会改变原始的LocalTime实例，而是返回一个新的实例。

• LocalTime.minus(long amountToSubtract, TemporalUnit unit)：此方法根据给定的时间量（以给定的时间单位为单位）从当前时间减去，并返回一个新的本地时间实例。例如，LocalTime.now().minus(2, ChronoUnit.HOURS)将返回一个新的本地时间，该时间比当前时间早2小时。

• LocalTime.minusHours(long hoursToSubtract)：此方法根据给定的小时数从当前时间减去，并返回一个新的本地时间实例。例如，LocalTime.now().minusHours(2)将返回一个新的本地时间，该时间比当前时间早2小时。

• LocalTime.minusMinutes(long minutesToSubtract)：此方法根据给定的分钟数从当前时间减去，并返回一个新的本地时间实例。例如，LocalTime.now().minusMinutes(30)将返回一个新的本地时间，该时间比当前时间早30分钟。

• LocalTime.minusSeconds(long secondsToSubtract)：此方法根据给定的秒数从当前时间减去，并返回一个新的本地时间实例。例如，LocalTime.now().minusSeconds(45)将返回一个新的本地时间，该时间比当前时间早45秒。

@Testpublic void test12() {    LocalTime localTime = LocalTime.of(20, 20, 30);    LocalTime minus = localTime.minus(10, ChronoUnit.HOURS);    System.out.println(minus);//输出结果：10:20:30    LocalTime localTime1 = localTime.minusHours(10);    System.out.println(localTime1.equals(minus));//输出结果：true    LocalTime minus1 = localTime.minus(10, ChronoUnit.MINUTES);    System.out.println(minus1);//输出结果：20:10:30    LocalTime localTime2 = localTime.minusMinutes(10);    System.out.println(localTime2.equals(minus1));//输出结果：true    LocalTime minus2 = localTime.minus(10, ChronoUnit.SECONDS);    System.out.println(minus2);//输出结果：20:20:20    LocalTime localTime3 = localTime.minusSeconds(10);    System.out.println(localTime3.equals(minus2));//输出结果：true}

LocalTime#query

LocalTime类中的query方法用于对时间进行查询和获取相关信息。它接受一个 TemporalQuery参数，该参数定义了要查询的时间属性和返回的数据类型。

@Testpublic void test13(){    LocalTime localTime=LocalTime.of(20,20,20);    TemporalQuery<Integer> temporalQuery=item->item.get(ChronoField.HOUR_OF_DAY);    Integer query = localTime.query(temporalQuery);    System.out.println(query);//输出结果：20}

LocalTime#until

LocalTime.until() 方法用于计算两个时间点之间的时间差。可以计算精确的时间差，包括天数、小时数、分钟数和秒数。它考虑了时间的小数部分，因此可以提供精确到秒的时间差。

@Testpublic void test14(){    LocalTime now = LocalTime.of(20,19);    long until = now.until(LocalTime.of(23, 19), ChronoUnit.HOURS);    System.out.println(until);//输出结果：3}

LocalTime#format

LocalTime类的format()方法用于将当前时间转换为指定的时间格式。该方法接受一个DateTimeFormatter对象作为参数，用于指定时间格式。DateTimeFormatter是Java 8引入的一个时间日期格式化工具，它提供了一种灵活的方式来指定日期和时间的格式。通过使用DateTimeFormatter，您可以定义所需的时间格式，例如使用特定的时间符号、日期格式和时区等。

@Testpublic void test15(){    LocalTime now = LocalTime.now();    String format = now.format(DateTimeFormatter.ISO_TIME);    System.out.println(format);//输出结果：11:59:12.4188079}

LocalTime#atDate

LocalTime类中的atDate()方法用于将LocalTime与日期（年、月、日）结合在一起，生成一个新的LocalDateTime对象。它接受一个LocalDate对象作为参数，并返回一个表示特定日期和时间的LocalDateTime对象。这个方法可以用于在给定日期的基础上添加时间信息，或者将时间与日期结合起来创建更完整的日期时间对象。通过将LocalTime与LocalDate结合使用，可以方便地创建包含日期和时间信息的对象，以便进行日程安排、计划等操作。

@Testpublic void test16(){    LocalTime localTime = LocalTime.of(20, 30, 59);    LocalDate localDate=LocalDate.of(2023,11,21);    LocalDateTime localDateTime = localTime.atDate(localDate);    System.out.println(localDateTime);//输出结果：2023-11-21T20:30:59
}

LocalTime#atOffset

LocalTime.atOffset()方法的功能是返回一个表示给定时间偏移量的OffsetTime对象，可以用于表示比本地时间更早或更晚的时间。通过将偏移量应用到本地时间上，可以方便地获取一个在特定偏移量之后或之前的另一个时间。

@Testpublic void test17(){    LocalTime localTime = LocalTime.of(20, 30, 59);    ZoneOffset zoneOffset=ZoneOffset.ofHours(8);    OffsetTime offsetTime = localTime.atOffset(zoneOffset);    System.out.println(offsetTime);//输出结果：20:30:59+08:00}

LocalTime#toSecondOfDay

LocalTime.toSecondOfDay()方法的功能是将当前LocalTime实例转换为从当天开始到该时间为止的秒数。

@Testpublic void test18(){    LocalTime localTime = LocalTime.of(1, 0, 0);    int secondOfDay = localTime.toSecondOfDay();    System.out.println(secondOfDay);//输出结果：3600}

LocalTime#toNanoOfDay

LocalTime.toNanoOfDay()通过将LocalTime对象中的时间成分（小时、分钟、秒和毫秒）转换为纳秒，可以获得一个表示该时间的纳秒级数值。这个数值表示的是从当天的午夜开始到该时间为止的总纳秒数。

@Testpublic void test19(){    LocalTime localTime = LocalTime.of(1, 0, 0);    Long nanoOfDay = localTime.toNanoOfDay();    System.out.println(nanoOfDay);//输出结果：3600000000000}

LocalTime#compareTo、LocalTime#isAfter、LocalTime#isBefore

LocalTime类中的compareTo()、isAfter()和isBefore()方法用于比较和处理时间。

• compareTo()方法：该方法用于比较两个LocalTime对象。它基于时间的时间点进行比较，返回一个整数值，表示当前时间对象与指定时间对象的相对顺序。如果当前时间对象在指定时间对象之前，则返回负整数；如果当前时间对象在指定时间对象之后，则返回正整数；如果两者相等，则返回0。

• isAfter()方法：该方法用于检查当前LocalTime对象是否在指定时间之后。它返回一个布尔值，如果当前时间对象在指定时间之后，则返回true；否则返回false。

• isBefore()方法：该方法用于检查当前LocalTime对象是否在指定时间之前。它返回一个布尔值，如果当前时间对象在指定时间之前，则返回true；否则返回false。

@Testpublic void  test20(){    LocalTime localTime=LocalTime.of(1,0,0);    LocalTime localTime1 = LocalTime.of(2, 30, 59);    int i = localTime.compareTo(localTime1);    System.out.println(i);//输出结果：-1    boolean after = localTime.isAfter(localTime1);    System.out.println(after);//输出结果：false    boolean before = localTime.isBefore(localTime1);    System.out.println(before);//输出结果：true}

适用场景

LocalTime是Java 8引入的一个类，用于表示一天中的时间，不包括日期信息。它在以下场景中特别有用：

• 时间计算和操作：LocalTime可以用于执行各种时间计算，如获取当前时间、增加或减少时间、计算两个时间的差等。

• 日程安排和提醒：如果你需要设置一个特定的时间进行任务或活动，例如会议、约会或闹钟，LocalTime可以用来表示这个特定的时间。

• 时间筛选：在处理大量数据时，可能需要基于时间进行筛选。例如，你可能需要找出在特定时间段内的所有交易记录。使用LocalTime可以很容易地定义和比较这些时间段。

• 时间格式化：LocalTime提供了一些方法来格式化和解析时间字符串。你可以使用DateTimeFormatter来定义你需要的格式，然后使用LocalTime的format()和parse()方法来进行格式化和解析。

• 时间展示和用户交互：如果需要在用户界面上显示或接收来自用户的时间输入，LocalTime可以用来表示这个时间。例如，你可能需要让用户选择一个特定的时间段来安排一个活动。

• 与其它日期/时间类型的交互：虽然LocalTime不包含日期信息，但它可以很容易地与包含日期的其他类（如LocalDateTime）进行交互。你可以从LocalDateTime中获取LocalTime，反之亦然。

• 时间戳操作：虽然LocalTime不直接提供时间戳功能，但你可以轻松地将其转换为Instant或ZonedDateTime，这两个类都提供了时间戳相关的功能。

总的来说，LocalTime适用于那些只需要处理一天中的时间，而不需要处理日期的场景。