模块 java.base
包 java.time

类 LocalTime

java.lang.Object
java.time.LocalTime
所有已实现的接口：
Serializable , Comparable<LocalTime> , Temporal , TemporalAccessor , TemporalAdjuster
public final class LocalTime extends Object implements Temporal , TemporalAdjuster , Comparable <LocalTime >, Serializable
ISO-8601 日历系统中没有时区的时间，例如 10:15:30 。

LocalTime 是一个不可变的日期时间对象，代表一个时间，通常被视为小时-分钟-秒。时间以纳秒精度表示。例如，值“13:45.30.123456789”可以存储在 LocalTime 中。

此类不存储或表示日期或时区。相反，它是对挂钟上所见当地时间的描述。如果没有偏移量或时区等附加信息，它不能代表时间线上的一个瞬间。

ISO-8601 日历系统是当今世界大部分地区使用的现代民用日历系统。此 API 假定所有日历系统都使用相同的表示形式，即此类，用于时间。

这是一个value-based类；程序员应该将 equal 的实例视为可互换的，并且不应使用实例进行同步，否则可能会发生不可预测的行为。例如，在未来的版本中，同步可能会失败。 equals 方法应该用于比较。

实现要求：
这个类是不可变的和线程安全的。
自从：
1.8
参见：

  • 字段详细信息

    • MIN

      public static final LocalTime  MIN
      支持的最小值 LocalTime，'00:00'。这是一天开始时的午夜时间。

    • MAX

      public static final LocalTime  MAX
      最大支持 LocalTime ，'23:59:59.999999999'。这是一天结束时午夜之前的时间。

    • MIDNIGHT

      public static final LocalTime  MIDNIGHT
      一天开始时的午夜时间，“00:00”。

    • NOON

      public static final LocalTime  NOON
      中午的时间，'12:00'。

  • 方法详情

    • now

      public static LocalTime  now()
      从默认时区的系统时钟获取当前时间。

      这将查询默认时区中的system clock 以获取当前时间。

      使用此方法将阻止使用备用时钟进行测试的能力，因为时钟是硬编码的。

      返回：
      使用系统时钟和默认时区的当前时间，不为空

    • now

      public static LocalTime  now(ZoneId  zone)
      从指定时区的系统时钟获取当前时间。

      这将查询 system clock 以获取当前时间。指定时区避免了对默认时区的依赖。

      使用此方法将阻止使用备用时钟进行测试的能力，因为时钟是硬编码的。

      参数：
      zone - 要使用的区域 ID，不为空
      返回：
      使用系统时钟的当前时间，不为空

    • now

      public static LocalTime  now(Clock  clock)
      从指定时钟获取当前时间。

      这将查询指定的时钟以获取当前时间。使用此方法允许使用备用时钟进行测试。可以使用 dependency injection 引入备用时钟。

      参数：
      clock - 使用的时钟，不为空
      返回：
      当前时间，不为空

    • of

      public static LocalTime  of(int hour, int minute)
      从小时和分钟中获取 LocalTime 的实例。

      这将返回具有指定小时和分钟的 LocalTime。秒和纳秒字段将设置为零。

      参数：
      hour - 要表示的小时数，从 0 到 23
      minute - 要表示的分钟数，从 0 到 59
      返回：
      当地时间，不为空
      抛出：
      DateTimeException - 如果任何字段的值超出范围

    • of

      public static LocalTime  of(int hour, int minute, int second)
      从小时、分钟和秒中获取 LocalTime 的实例。

      这将返回具有指定小时、分钟和秒的 LocalTime。纳秒字段将设置为零。

      参数：
      hour - 要表示的小时数，从 0 到 23
      minute - 要表示的分钟数，从 0 到 59
      second - 表示的秒数，从 0 到 59
      返回：
      当地时间，不为空
      抛出：
      DateTimeException - 如果任何字段的值超出范围

    • of

      public static LocalTime  of(int hour, int minute, int second, int nanoOfSecond)
      从小时、分钟、秒和纳秒中获取 LocalTime 的实例。

      这将返回具有指定小时、分钟、秒和纳秒的 LocalTime。

      参数：
      hour - 要表示的小时数，从 0 到 23
      minute - 要表示的分钟数，从 0 到 59
      second - 表示的秒数，从 0 到 59
      nanoOfSecond - 表示的纳秒，从 0 到 999,999,999
      返回：
      当地时间，不为空
      抛出：
      DateTimeException - 如果任何字段的值超出范围

    • ofInstant

      public static LocalTime  ofInstant(Instant  instant, ZoneId  zone)
      从 Instant 和区域 ID 获取 LocalTime 的实例。

      这将根据指定的时刻创建本地时间。首先，使用区域 ID 和时刻获得与 UTC/格林威治的偏移量，这很简单，因为每个时刻只有一个有效偏移量。然后，瞬时和偏移量用于计算本地时间。

      参数：
      instant - 创建时间的瞬间，不为空
      zone - 时区，可能是一个偏移量，不为空
      返回：
      当地时间，不为空
      自从：
      9

    • ofSecondOfDay

      public static LocalTime  ofSecondOfDay(long secondOfDay)
      从第二天的值中获取 LocalTime 的实例。

      这将返回具有指定第二天的 LocalTime。纳秒字段将设置为零。

      参数：
      secondOfDay - 第二天，从 0 到 24 * 60 * 60 - 1
      返回：
      当地时间，不为空
      抛出：
      DateTimeException - 如果第二天值无效

    • ofNanoOfDay

      public static LocalTime  ofNanoOfDay(long nanoOfDay)
      从一个纳米级的值中获取 LocalTime 的一个实例。

      这将返回具有指定纳秒级的 LocalTime。

      参数：
      nanoOfDay - 一天的纳米，从 0 到 24 * 60 * 60 * 1,000,000,000 - 1
      返回：
      当地时间，不为空
      抛出：
      DateTimeException - 如果日值的纳米无效

    • from

      public static LocalTime  from(TemporalAccessor  temporal)
      从时间对象中获取 LocalTime 的实例。

      这将根据指定的时间获取本地时间。 TemporalAccessor 表示一组任意的日期和时间信息，该工厂将其转换为 LocalTime 的一个实例。

      转换使用 TemporalQueries.localTime() 查询，它依赖于提取 NANO_OF_DAY 字段。

      此方法与功能接口 TemporalQuery 的签名相匹配，允许它通过方法参考 LocalTime::from 用作查询。

      参数：
      temporal - 要转换的时间对象，不为空
      返回：
      当地时间，不为空
      抛出：
      DateTimeException - 如果无法转换为 LocalTime

    • parse

      public static LocalTime  parse(CharSequence  text)
      从 10:15 等文本字符串中获取 LocalTime 的实例。

      该字符串必须表示有效时间并使用 DateTimeFormatter.ISO_LOCAL_TIME 进行解析。

      参数：
      text - 要解析的文本，例如“10:15:30”，不为空
      返回：
      解析的本地时间，不为空
      抛出：
      DateTimeParseException - 如果无法解析文本

    • parse

      public static LocalTime  parse(CharSequence  text, DateTimeFormatter  formatter)
      使用特定格式化程序从文本字符串中获取 LocalTime 的实例。

      使用格式化程序解析文本，返回时间。

      参数：
      text - 要解析的文本，不为空
      formatter - 要使用的格式化程序，不为空
      返回：
      解析的本地时间，不为空
      抛出：
      DateTimeParseException - 如果无法解析文本

    • isSupported

      public boolean isSupported(TemporalField  field)
      检查是否支持指定的字段。

      这将检查是否可以查询指定字段的时间。如果为 false，则调用 range 、get 和 with(TemporalField, long) 方法将抛出异常。

      如果该字段是一个ChronoField 那么查询就在这里实现。支持的字段是：

      • NANO_OF_SECOND
      • NANO_OF_DAY
      • MICRO_OF_SECOND
      • MICRO_OF_DAY
      • MILLI_OF_SECOND
      • MILLI_OF_DAY
      • SECOND_OF_MINUTE
      • SECOND_OF_DAY
      • MINUTE_OF_HOUR
      • MINUTE_OF_DAY
      • HOUR_OF_AMPM
      • CLOCK_HOUR_OF_AMPM
      • HOUR_OF_DAY
      • CLOCK_HOUR_OF_DAY
      • AMPM_OF_DAY
      所有其他 ChronoField 实例将返回 false。

      如果该字段不是 ChronoField ，则通过调用 TemporalField.isSupportedBy(TemporalAccessor) 传递 this 作为参数来获得此方法的结果。字段是否支持由字段决定。

      指定者：
      isSupported 在接口 TemporalAccessor 中
      参数：
      field - 要检查的字段，null 返回 false
      返回：
      如果此时支持该字段，则为 true，否则为 false

    • isSupported

      public boolean isSupported(TemporalUnit  unit)
      检查是否支持指定的单位。

      这将检查这次是否可以添加或减去指定的单位。如果为 false，则调用 plus(long, TemporalUnit) 和 minus 方法将抛出异常。

      如果单位是ChronoUnit 那么查询就是在这里实现的。支持的单位有：

      • NANOS
      • MICROS
      • MILLIS
      • SECONDS
      • MINUTES
      • HOURS
      • HALF_DAYS
      所有其他 ChronoUnit 实例将返回 false。

      如果单位不是 ChronoUnit ，则通过调用 TemporalUnit.isSupportedBy(Temporal) 传递 this 作为参数来获得此方法的结果。是否支持该单元由单元决定。

      指定者：
      isSupported 在接口 Temporal 中
      参数：
      unit - 要检查的单位，null 返回 false
      返回：
      如果可以添加/减去单位，则为 true，否则为 false

    • range

      public ValueRange  range(TemporalField  field)
      获取指定字段的有效值范围。

      范围对象表示字段的最小和最大有效值。该时间用于增强返回范围的准确性。如果由于不支持该字段或其他原因而无法返回范围，则会抛出异常。

      如果该字段是一个ChronoField 那么查询就在这里实现。 supported fields 将返回适当的范围实例。所有其他 ChronoField 实例将抛出 UnsupportedTemporalTypeException 。

      如果该字段不是 ChronoField ，则通过调用 TemporalField.rangeRefinedBy(TemporalAccessor) 传递 this 作为参数来获得此方法的结果。能否获取范围由字段决定。

      指定者：
      range 在接口 TemporalAccessor 中
      参数：
      field - 查询范围的字段，不为空
      返回：
      该字段的有效值范围，不为空
      抛出：
      DateTimeException - 如果无法获得该字段的范围
      UnsupportedTemporalTypeException - 如果不支持该字段

    • get

      public int get(TemporalField  field)
      从此时开始获取指定字段的值作为 int 。

      这一次查询指定字段的值。返回值将始终在该字段的有效值范围内。如果由于不支持该字段或其他原因而无法返回该值，则会抛出异常。

      如果该字段是一个ChronoField 那么查询就在这里实现。 supported fields 将根据此时间返回有效值，但 NANO_OF_DAY 和 MICRO_OF_DAY 除外，它们太大而无法放入 int 并抛出 UnsupportedTemporalTypeException 。所有其他 ChronoField 实例将抛出 UnsupportedTemporalTypeException 。

      如果该字段不是 ChronoField ，则通过调用 TemporalField.getFrom(TemporalAccessor) 传递 this 作为参数来获得此方法的结果。能否获取到该值，该值代表什么，由字段决定。

      指定者：
      get 在接口 TemporalAccessor 中
      参数：
      field - 要获取的字段，不为空
      返回：
      该字段的值
      抛出：
      DateTimeException - 如果无法获取该字段的值或该值超出该字段的有效值范围
      UnsupportedTemporalTypeException - 如果不支持该字段或值的范围超过 int
      ArithmeticException - 如果发生数字溢出

    • getLong

      public long getLong(TemporalField  field)
      从此时开始获取指定字段的值作为 long 。

      这一次查询指定字段的值。如果由于不支持该字段或其他原因而无法返回该值，则会抛出异常。

      如果该字段是一个ChronoField 那么查询就在这里实现。 supported fields 将根据此时间返回有效值。所有其他 ChronoField 实例将抛出 UnsupportedTemporalTypeException 。

      如果该字段不是 ChronoField ，则通过调用 TemporalField.getFrom(TemporalAccessor) 传递 this 作为参数来获得此方法的结果。能否获取到该值，该值代表什么，由字段决定。

      指定者：
      getLong 在接口 TemporalAccessor 中
      参数：
      field - 要获取的字段，不为空
      返回：
      该字段的值
      抛出：
      DateTimeException - 如果无法获得该字段的值
      UnsupportedTemporalTypeException - 如果不支持该字段
      ArithmeticException - 如果发生数字溢出

    • getHour

      public int getHour()
      获取一天中的小时字段。
      返回：
      一天中的小时，从 0 到 23

    • getMinute

      public int getMinute()
      获取分钟字段。
      返回：
      小时的分钟数，从 0 到 59

    • getSecond

      public int getSecond()
      获取秒字段。
      返回：
      秒，从 0 到 59

    • getNano

      public int getNano()
      获取纳秒级字段。
      返回：
      纳秒，从 0 到 999,999,999

    • with

      public LocalTime  with(TemporalAdjuster  adjuster)
      返回此时间的调整副本。

      这将返回一个 LocalTime ，基于这个，并调整了时间。使用指定的调整器策略对象进行调整。阅读调整器的文档以了解将进行的调整。

      一个简单的调整器可能只设置其中一个字段，例如小时字段。更复杂的调节器可能会将时间设置为一天的最后一个小时。

      此方法的结果是通过在指定的调节器上调用 TemporalAdjuster.adjustInto(Temporal) 方法并将 this 作为参数传递来获得的。

      此实例是不可变的，不受此方法调用的影响。

      指定者：
      with 在接口 Temporal 中
      参数：
      adjuster - 要使用的调节器，不为空
      返回：
      a LocalTime 基于 this 并进行了调整，不为空
      抛出：
      DateTimeException - 如果无法进行调整
      ArithmeticException - 如果发生数字溢出

    • with

      public LocalTime  with(TemporalField  field, long newValue)
      返回此时间的副本，并将指定字段设置为新值。

      这将返回一个 LocalTime ，基于这个，指定字段的值已更改。这可用于更改任何支持的字段，例如小时、分钟或秒。如果无法设置该值，因为不支持该字段或出于其他原因，则会抛出异常。

      如果该字段是 ChronoField 则在此处执行调整。支持的字段行为如下：

      • NANO_OF_SECOND - 返回具有指定纳秒的 LocalTime。小时、分钟和秒将保持不变。
      • NANO_OF_DAY - 返回具有指定纳日的 LocalTime。这完全取代了时间，相当于 ofNanoOfDay(long) 。
      • MICRO_OF_SECOND - 返回一个 LocalTime，其中纳秒替换为指定的微秒乘以 1,000。小时、分钟和秒将保持不变。
      • MICRO_OF_DAY - 返回具有指定微日的 LocalTime。这完全取代了时间，相当于使用 ofNanoOfDay(long) 和微日乘以 1,000。
      • MILLI_OF_SECOND - 返回一个 LocalTime，其中纳秒替换为指定的毫秒乘以 1,000,000。小时、分钟和秒将保持不变。
      • MILLI_OF_DAY - 返回具有指定毫秒数的 LocalTime。这完全取代了时间，相当于使用 ofNanoOfDay(long) 将毫秒数乘以 1,000,000。
      • SECOND_OF_MINUTE - 返回具有指定秒数的 LocalTime。小时、分钟和纳秒将保持不变。
      • SECOND_OF_DAY - 返回具有指定第二天的 LocalTime。纳秒将保持不变。
      • MINUTE_OF_HOUR - 返回具有指定分钟数的 LocalTime。小时、分秒和纳秒将保持不变。
      • MINUTE_OF_DAY - 返回具有指定分钟数的 LocalTime。秒和纳秒将保持不变。
      • HOUR_OF_AMPM - 返回具有指定小时的 LocalTime。 AM/PM、分时、分秒和纳秒将保持不变。
      • CLOCK_HOUR_OF_AMPM - 返回具有指定时钟时间的 LocalTime。 AM/PM、分时、分秒和纳秒将保持不变。
      • HOUR_OF_DAY - 返回具有指定小时的 LocalTime。分钟、分钟和纳秒将保持不变。
      • CLOCK_HOUR_OF_DAY - 返回具有指定时钟时间的 LocalTime。分钟、分钟和纳秒将保持不变。
      • AMPM_OF_DAY - 返回具有指定 AM/PM 的 LocalTime。上午-下午的小时、小时的分钟、分钟的秒和纳秒将保持不变。

      在所有情况下，如果新值超出该字段的有效值范围，则会抛出 DateTimeException。

      所有其他 ChronoField 实例将抛出 UnsupportedTemporalTypeException 。

      如果该字段不是 ChronoField ，则通过调用 TemporalField.adjustInto(Temporal, long) 传递 this 作为参数来获得此方法的结果。在这种情况下，该字段决定是否以及如何调整瞬间。

      此实例是不可变的，不受此方法调用的影响。

      指定者：
      with 在接口 Temporal 中
      参数：
      field - 要在结果中设置的字段，不为空
      newValue - 结果中字段的新值
      返回：
      基于 this 的 LocalTime 具有指定的字段集，不为空
      抛出：
      DateTimeException - 如果无法设置字段
      UnsupportedTemporalTypeException - 如果不支持该字段
      ArithmeticException - 如果发生数字溢出

    • withHour

      public LocalTime  withHour(int hour)
      返回此 LocalTime 的副本，其中更改了一天中的小时数。

      此实例是不可变的，不受此方法调用的影响。

      参数：
      hour - 在结果中设置的小时数，从 0 到 23
      返回：
      LocalTime 基于这个时间和请求的时间，不为空
      抛出：
      DateTimeException - 如果小时值无效

    • withMinute

      public LocalTime  withMinute(int minute)
      返回此 LocalTime 的副本，并更改了分钟。

      此实例是不可变的，不受此方法调用的影响。

      参数：
      minute - 在结果中设置的分钟数，从 0 到 59
      返回：
      LocalTime 基于这个时间和请求的分钟数，不为空
      抛出：
      DateTimeException - 如果分钟值无效

    • withSecond

      public LocalTime  withSecond(int second)
      返回此 LocalTime 的副本，并更改了秒数。

      此实例是不可变的，不受此方法调用的影响。

      参数：
      second - 在结果中设置的秒数，从 0 到 59
      返回：
      LocalTime 基于这个时间和请求的秒数，不为空
      抛出：
      DateTimeException - 如果第二个值无效

    • withNano

      public LocalTime  withNano(int nanoOfSecond)
      返回此 LocalTime 的副本，并更改了纳秒级。

      此实例是不可变的，不受此方法调用的影响。

      参数：
      nanoOfSecond - 在结果中设置的纳秒，从 0 到 999,999,999
      返回：
      LocalTime 基于这个时间请求的纳秒，不为空
      抛出：
      DateTimeException - 如果纳米值无效

    • truncatedTo

      public LocalTime  truncatedTo(TemporalUnit  unit)
      返回此 LocalTime 的副本，时间被截断。

      截断返回原始时间的副本，其中小于指定单位的字段设置为零。例如，使用 minutes 单位截断会将秒和纳秒字段设置为零。

      该单位必须有一个 duration，它可以划分为一个标准日的长度，没有余数。这包括 ChronoUnit 和 DAYS 上所有提供的时间单位。其他单位抛出异常。

      此实例是不可变的，不受此方法调用的影响。

      参数：
      unit - 要截断的单位，不为空
      返回：
      LocalTime 基于这个时间截断的时间，不为空
      抛出：
      DateTimeException - 如果无法截断
      UnsupportedTemporalTypeException - 如果不支持该单元

    • plus

      public LocalTime  plus(TemporalAmount  amountToAdd)
      返回添加了指定数量的此时间的副本。

      这将返回一个 LocalTime ，基于这个，添加了指定的数量。数量通常是 Duration 但可以是实现 TemporalAmount 接口的任何其他类型。

      通过调用 TemporalAmount.addTo(Temporal) 将计算委托给金额对象。金额实现可以自由地以任何它希望的方式实现加法，但是它通常会回调 plus(long, TemporalUnit) 。查阅amount实现的文档，判断是否可以添加成功。

      此实例是不可变的，不受此方法调用的影响。

      指定者：
      plus 在接口 Temporal 中
      参数：
      amountToAdd - 添加的数量，不为空
      返回：
      a LocalTime 基于这次添加，不为空
      抛出：
      DateTimeException - 如果无法添加
      ArithmeticException - 如果发生数字溢出

    • plus

      public LocalTime  plus(long amountToAdd, TemporalUnit  unit)
      返回添加了指定数量的此时间的副本。

      这将返回一个 LocalTime ，基于这个，以添加的单位表示数量。如果由于不支持该单位或其他原因而无法添加金额，则会抛出异常。

      如果该字段是ChronoUnit ，则在此处实现加法。支持的字段行为如下：

      • NANOS - 返回添加了指定纳秒数的 LocalTime。这相当于 plusNanos(long) 。
      • MICROS - 返回添加了指定微秒数的 LocalTime。这相当于 plusNanos(long) 的数量乘以 1,000。
      • MILLIS - 返回添加了指定毫秒数的 LocalTime。这相当于 plusNanos(long) 的金额乘以 1,000,000。
      • SECONDS - 返回添加了指定秒数的 LocalTime。这相当于 plusSeconds(long) 。
      • MINUTES - 返回添加了指定分钟数的 LocalTime。这相当于 plusMinutes(long) 。
      • HOURS - 返回添加了指定小时数的 LocalTime。这相当于 plusHours(long) 。
      • HALF_DAYS - 返回一个 LocalTime 添加了指定的半天数。这相当于 plusHours(long) 的数量乘以 12。

      所有其他 ChronoUnit 实例将抛出 UnsupportedTemporalTypeException 。

      如果该字段不是 ChronoUnit ，则通过调用 TemporalUnit.addTo(Temporal, long) 传递 this 作为参数来获得此方法的结果。在这种情况下，该单元确定是否以及如何执行加法。

      此实例是不可变的，不受此方法调用的影响。

      指定者：
      plus 在接口 Temporal 中
      参数：
      amountToAdd - 添加到结果的单位数量，可能为负数
      unit - 添加量的单位，不为空
      返回：
      a LocalTime 基于这个时间加上指定的数量，不为空
      抛出：
      DateTimeException - 如果无法添加
      UnsupportedTemporalTypeException - 如果不支持该单元
      ArithmeticException - 如果发生数字溢出

    • plusHours

      public LocalTime  plusHours(long hoursToAdd)
      返回此 LocalTime 的副本，其中添加了指定的小时数。

      这会将指定的小时数添加到这个时间，返回一个新时间。计算在午夜左右结束。

      此实例是不可变的，不受此方法调用的影响。

      参数：
      hoursToAdd - 添加的小时数，可能为负数
      返回：
      LocalTime 基于这个时间加上小时数，不为空

    • plusMinutes

      public LocalTime  plusMinutes(long minutesToAdd)
      返回此 LocalTime 的副本，并添加了指定的分钟数。

      这会将指定的分钟数添加到这个时间，返回一个新时间。计算在午夜左右结束。

      此实例是不可变的，不受此方法调用的影响。

      参数：
      minutesToAdd - 添加的分钟数，可能为负数
      返回：
      LocalTime 基于这个时间加上分钟数，不为空

    • plusSeconds

      public LocalTime  plusSeconds(long secondstoAdd)
      返回此 LocalTime 的副本，并添加了指定的秒数。

      这会将指定的秒数添加到这个时间，返回一个新时间。计算在午夜左右结束。

      此实例是不可变的，不受此方法调用的影响。

      参数：
      secondstoAdd - 添加的秒数，可能为负
      返回：
      LocalTime 基于这个时间加上秒数，不为空

    • plusNanos

      public LocalTime  plusNanos(long nanosToAdd)
      返回此 LocalTime 的副本，并添加了指定的纳秒数。

      这会将指定的纳秒数添加到该时间，返回一个新时间。计算在午夜左右结束。

      此实例是不可变的，不受此方法调用的影响。

      参数：
      nanosToAdd - 要添加的纳米，可能为负
      返回：
      LocalTime 基于这个时间加上纳秒，不为空

    • minus

      public LocalTime  minus(TemporalAmount  amountToSubtract)
      返回此时间的副本，并减去指定的数量。

      这将返回一个 LocalTime ，基于这个，减去指定的数量。数量通常是 Duration 但可以是实现 TemporalAmount 接口的任何其他类型。

      通过调用 TemporalAmount.subtractFrom(Temporal) 将计算委托给金额对象。金额实现可以自由地以任何它希望的方式实现减法，但是它通常会回调 minus(long, TemporalUnit) 。查阅 amount 实现的文档以确定是否可以成功减去。

      此实例是不可变的，不受此方法调用的影响。

      指定者：
      minus 在接口 Temporal 中
      参数：
      amountToSubtract - 要减去的金额，不为空
      返回：
      a LocalTime 基于这次减法，不为空
      抛出：
      DateTimeException - 如果无法进行减法
      ArithmeticException - 如果发生数字溢出

    • minus

      public LocalTime  minus(long amountToSubtract, TemporalUnit  unit)
      返回此时间的副本，并减去指定的数量。

      这将返回一个 LocalTime ，基于这个，减去单位数量。如果无法减去金额，因为不支持该单位或出于其他原因，则会抛出异常。

      此方法等同于 plus(long, TemporalUnit) 取反金额。有关加法和减法如何工作的完整描述，请参阅该方法。

      此实例是不可变的，不受此方法调用的影响。

      指定者：
      minus 在接口 Temporal 中
      参数：
      amountToSubtract - 要从结果中减去的单位数量，可能为负数
      unit - 要减去的金额的单位，不为空
      返回：
      a LocalTime 基于这个时间减去指定的数量，不为空
      抛出：
      DateTimeException - 如果无法进行减法
      UnsupportedTemporalTypeException - 如果不支持该单元
      ArithmeticException - 如果发生数字溢出

    • minusHours

      public LocalTime  minusHours(long hoursToSubtract)
      返回此 LocalTime 的副本，并减去指定的小时数。

      从这个时间减去指定的小时数，返回一个新的时间。计算在午夜左右结束。

      此实例是不可变的，不受此方法调用的影响。

      参数：
      hoursToSubtract - 要减去的小时数，可能为负数
      返回：
      LocalTime 基于这个时间减去小时数，不为空

    • minusMinutes

      public LocalTime  minusMinutes(long minutesToSubtract)
      返回此 LocalTime 的副本，并减去指定的分钟数。

      从这个时间减去指定的分钟数，返回一个新的时间。计算在午夜左右结束。

      此实例是不可变的，不受此方法调用的影响。

      参数：
      minutesToSubtract - 要减去的分钟数，可能为负数
      返回：
      LocalTime 基于这个时间减去分钟数，不为空

    • minusSeconds

      public LocalTime  minusSeconds(long secondsToSubtract)
      返回此 LocalTime 的副本，并减去指定的秒数。

      从这个时间减去指定的秒数，返回一个新的时间。计算在午夜左右结束。

      此实例是不可变的，不受此方法调用的影响。

      参数：
      secondsToSubtract - 减去的秒数，可能为负数
      返回：
      LocalTime 基于这个时间减去秒数，不为空

    • minusNanos

      public LocalTime  minusNanos(long nanosToSubtract)
      返回此 LocalTime 的副本，并减去指定的纳秒数。

      这将从该时间中减去指定的纳秒数，返回一个新时间。计算在午夜左右结束。

      此实例是不可变的，不受此方法调用的影响。

      参数：
      nanosToSubtract - 要减去的纳米，可能是负数
      返回：
      LocalTime 基于这个时间减去纳秒，不为空

    • query

      public <R> R query(TemporalQuery <R> query)
      这次查询使用指定的查询。

      这次使用指定的查询策略对象进行查询。 TemporalQuery 对象定义了用于获取结果的逻辑。阅读查询文档以了解此方法的结果。

      此方法的结果是通过对指定查询调用 TemporalQuery.queryFrom(TemporalAccessor) 方法并将 this 作为参数传递来获得的。

      指定者：
      query 在接口 TemporalAccessor 中
      类型参数：
      R - 结果的类型
      参数：
      query - 要调用的查询，不为空
      返回：
      查询结果，可能返回null（由查询定义）
      抛出：
      DateTimeException - 如果无法查询（由查询定义）
      ArithmeticException - 如果发生数字溢出（由查询定义）

    • adjustInto

      public Temporal  adjustInto(Temporal  temporal)
      将指定的时间对象调整为与此对象具有相同的时间。

      这将返回一个与输入相同的可观察类型的时间对象，时间更改为与此相同。

      调整相当于使用Temporal.with(TemporalField, long) 传递ChronoField.NANO_OF_DAY 作为字段。

      在大多数情况下，使用 Temporal.with(TemporalAdjuster) 反转调用模式会更清楚：

        // these two lines are equivalent, but the second approach is recommended
  temporal = thisLocalTime.adjustInto(temporal);
  temporal = temporal.with(thisLocalTime);

      此实例是不可变的，不受此方法调用的影响。

      指定者：
      adjustInto 在接口 TemporalAdjuster 中
      参数：
      temporal - 要调整的目标对象，不为空
      返回：
      调整后的对象，不为空
      抛出：
      DateTimeException - 如果无法进行调整
      ArithmeticException - 如果发生数字溢出

    • until

      public long until(Temporal  endExclusive, TemporalUnit  unit)
      根据指定的单位计算到另一个时间为止的时间量。

      这根据单个 TemporalUnit 计算两个 LocalTime 对象之间的时间量。起点和终点是this和指定的时间。如果结束早于开始，结果将为负。传递给此方法的 Temporal 使用 from(TemporalAccessor) 转换为 LocalTime。例如，可以使用 startTime.until(endTime, HOURS) 计算两次之间的小时数。

      计算返回一个整数，代表两次之间的完整单位数。例如，11:30 到 13:29 之间的小时数将仅为一小时，因为两小时差一分钟。

      有两种等效的方法可以使用此方法。第一个是调用这个方法。第二种是使用 TemporalUnit.between(Temporal, Temporal) ：

        // these two lines are equivalent
  amount = start.until(end, MINUTES);
  amount = MINUTES.between(start, end);
      应该根据哪个使代码更具可读性来做出选择。

      ChronoUnit 的计算在此方法中实现。支持单位 NANOS、MICROS、MILLIS、SECONDS、MINUTES、HOURS 和 HALF_DAYS。其他 ChronoUnit 值将引发异常。

      如果单位不是 ChronoUnit ，则通过调用 TemporalUnit.between(Temporal, Temporal) 将 this 作为第一个参数并将转换后的输入时间作为第二个参数来获得此方法的结果。

      此实例是不可变的，不受此方法调用的影响。

      指定者：
      until 在接口 Temporal 中
      参数：
      endExclusive - 结束时间，独占，转换为 LocalTime ，不为空
      unit - 衡量数量的单位，不为空
      返回：
      这个时间和结束时间之间的时间量
      抛出：
      DateTimeException - 如果无法计算金额，或者结束时间无法转换为 LocalTime
      UnsupportedTemporalTypeException - 如果不支持该单元
      ArithmeticException - 如果发生数字溢出

    • format

      public String  format(DateTimeFormatter  formatter)
      这次使用指定的格式化程序进行格式化。

      这次将传递给格式化程序以生成字符串。

      参数：
      formatter - 要使用的格式化程序，不为空
      返回：
      格式化的时间字符串，不为空
      抛出：
      DateTimeException - 如果在打印过程中发生错误

    • atDate

      public LocalDateTime  atDate(LocalDate  date)
      将这个时间与日期结合起来创建一个 LocalDateTime 。

      这将返回从指定日期的此时开始形成的 LocalDateTime。日期和时间的所有可能组合均有效。

      参数：
      date - 要合并的日期，不为空
      返回：
      从这个时间和指定日期形成的本地日期时间，不为空

    • atOffset

      public OffsetTime  atOffset(ZoneOffset  offset)
      将这个时间与偏移量结合起来创建一个 OffsetTime 。

      这将返回从此时在指定偏移处形成的 OffsetTime。时间和偏移量的所有可能组合都是有效的。

      参数：
      offset - 要结合的偏移量，不为空
      返回：
      从这个时间和指定的偏移量形成的偏移时间，不为空

    • toSecondOfDay

      public int toSecondOfDay()
      将时间提取为一天中的秒数，从 0 到 24 * 60 * 60 - 1 。
      返回：
      相当于这次的第二天

    • toNanoOfDay

      public long toNanoOfDay()
      将时间提取为一天的纳秒，从 0 到 24 * 60 * 60 * 1,000,000,000 - 1 。
      返回：
      相当于这次的 day 的 nano

    • toEpochSecond

      public long toEpochSecond(LocalDate  date, ZoneOffset  offset)
      将此 LocalTime 转换为自 1970-01-01T00:00:00Z 纪元以来的秒数。

      这会将本地时间与指定日期和偏移量结合起来计算纪元秒值，即从 1970-01-01T00:00:00Z 开始经过的秒数。时代之后的时间线上的瞬间是正的，更早的是负的。

      参数：
      date - 本地日期，不为空
      offset - 区域偏移量，不为空
      返回：
      自 1970-01-01T00:00:00Z 纪元以来的秒数，可能为负数
      自从：
      9

    • compareTo

      public int compareTo(LocalTime  other)
      将这次与另一次进行比较。

      比较是基于一天内当地时间的时间线位置。正如 Comparable 所定义的那样，它“与等于一致”。

      指定者：
      compareTo 在接口 Comparable<LocalTime> 中
      参数：
      other - 另一个要比较的时间，不为空
      返回：
      比较值，小于则为负，大于则为正

    • isAfter

      public boolean isAfter(LocalTime  other)
      检查此时间是否在指定时间之后。

      比较是基于一天内时间的时间线位置。

      参数：
      other - 另一个要比较的时间，不为空
      返回：
      如果这是在指定时间之后，则为真

    • isBefore

      public boolean isBefore(LocalTime  other)
      检查此时间是否在指定时间之前。

      比较是基于一天内时间的时间线位置。

      参数：
      other - 另一个要比较的时间，不为空
      返回：
      如果这一点在指定时间之前，则为真

    • equals

      public boolean equals(Object  obj)
      检查这个时间是否等于另一个时间。

      比较是基于一天内时间的时间线位置。

      只比较 LocalTime 类型的对象，其他类型返回 false。要比较两个 TemporalAccessor 实例的日期，请使用 ChronoField.NANO_OF_DAY 作为比较器。

      重写：
      equals 在类 Object 中
      参数：
      obj - 要检查的对象，null 返回 false
      返回：
      如果这等于其他时间，则为真
      参见：

    • hashCode

      public int hashCode()
      这次的哈希码。
      重写：
      hashCode 在类 Object 中
      返回：
      合适的哈希码
      参见：

    • toString

      public String  toString()
      这次输出为 String ，例如 10:15 。

      输出将是以下 ISO-8601 格式之一：

      • HH:mm
      • HH:mm:ss
      • HH:mm:ss.SSS
      • HH:mm:ss.SSSSSS
      • HH:mm:ss.SSSSSSSSS
      使用的格式将是输出时间的完整值的最短格式，其中省略的部分隐含为零。
      重写：
      toString 在类 Object 中
      返回：
      这次的字符串表示形式，不为空