Module java.base
Package java.time

Class OffsetTime

java.lang.Object
java.time.OffsetTime
所有已实现的接口:
Serializable, Comparable<OffsetTime>, Temporal, TemporalAccessor, TemporalAdjuster
public final class OffsetTime extends Object implements Temporal, TemporalAdjuster, Comparable<OffsetTime>, Serializable
一个带有UTC/Greenwich偏移的ISO-8601日历系统中的时间，例如10:15:30+01:00。

OffsetTime是一个不可变的日期时间对象，表示时间，通常被视为小时-分钟-秒-偏移。该类存储所有时间字段，精确到纳秒，以及一个区偏移。例如，值"13:45:30.123456789+02:00"可以存储在一个OffsetTime中。

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

实现要求:
该类是不可变的且线程安全的。
自 JDK 版本:
1.8
参见:

  • Field Details

    • MIN

      public static final OffsetTime MIN
      支持的最小OffsetTime为'00:00:00+18:00'。这是在最大偏移（较大的偏移在时间线上更早）的一天开始时刻的午夜时间。这结合了LocalTime.MIN和ZoneOffset.MAX。这可以被应用程序用作“遥远过去”的日期。

    • MAX

      public static final OffsetTime MAX
      支持的最大OffsetTime为'23:59:59.999999999-18:00'。这是在最小偏移（较大的负偏移在时间线上更晚）的一天结束前的午夜时间。这结合了LocalTime.MAX和ZoneOffset.MIN。这可以被应用程序用作“遥远未来”的日期。

  • Method Details

    • now

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

      这将查询默认时区中的系统时钟以获取当前时间。偏移将根据时钟中的时区计算。

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

      返回:
      使用系统时钟和默认时区获取的当前时间，非空

    • now

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

      这将查询系统时钟以获取当前时间。指定时区避免依赖默认时区。偏移将根据指定的时区计算。

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

      参数:
      zone - 要使用的区域 ID，非空
      返回:
      使用系统时钟获取的当前时间，非空

    • now

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

      这将查询指定的时钟以获取当前时间。偏移将根据时钟中的时区计算。

      使用此方法允许使用替代时钟进行测试。可以使用依赖注入引入替代时钟。

      参数:
      clock - 要使用的时钟，非空
      返回:
      当前时间，非空

    • of

      public static OffsetTime of(LocalTime time, ZoneOffset offset)
      从本地时间和偏移获取OffsetTime的实例。
      参数:
      time - 本地时间，非空
      offset - 区偏移，非空
      返回:
      偏移时间，非空

    • of

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

      使用四个指定字段创建一个偏移时间。

      此方法主要用于编写测试用例。非测试代码通常会使用其他方法来创建偏移时间。LocalTime有两个等效工厂方法的便利变体，接受较少的参数。这里没有提供它们，以减少 API 的占用空间。

      参数:
      hour - 表示的小时数，范围从0到23
      minute - 表示的分钟数，范围从0到59
      second - 表示的秒数，范围从0到59
      nanoOfSecond - 表示的纳秒数，范围从0到999,999,999
      offset - 时区偏移量，不能为空
      返回:
      偏移时间，不能为空
      抛出:
      DateTimeException - 如果任何字段的值超出范围

    • ofInstant

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

      这将创建一个具有与指定时间相同的瞬时偏移时间。从UTC/Greenwich获取偏移量很简单，因为每个瞬时只有一个有效的偏移量。

      在转换过程中会丢弃瞬时的日期部分。这意味着转换永远不会因为瞬时超出有效日期范围而失败。

      参数:
      instant - 创建时间的瞬时时间，不能为空
      zone - 时区，可以是偏移量，不能为空
      返回:
      偏移时间，不能为空

    • from

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

      根据指定的时间对象获取偏移时间。 TemporalAccessor表示一组任意的日期和时间信息，此工厂将其转换为OffsetTime的实例。

      转换会提取并组合时间对象中的ZoneOffset和LocalTime。实现允许执行优化，例如访问等效于相关对象的字段。

      此方法与函数接口TemporalQuery的签名匹配，允许通过方法引用OffsetTime::from来使用它作为查询。

      参数:
      temporal - 要转换的时间对象，不能为空
      返回:
      偏移时间，不能为空
      抛出:
      DateTimeException - 如果无法转换为OffsetTime

    • parse

      public static OffsetTime parse(CharSequence text)
      从文本字符串（例如10:15:30+01:00）获取OffsetTime的实例。

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

      参数:
      text - 要解析的文本，例如"10:15:30+01:00"，不能为空
      返回:
      解析的本地时间，不能为空
      抛出:
      DateTimeParseException - 如果无法解析文本

    • parse

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

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

      参数:
      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
      • OFFSET_SECONDS
      所有其他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，则在此处实现查询。支持的字段将返回适当的范围实例。所有其他ChronoField实例将抛出UnsupportedTemporalTypeException。

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

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

    • get

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

      查询此时间以获取指定字段的值。返回的值将始终在字段的有效值范围内。如果无法返回值，因为不支持字段或出于其他原因，将抛出异常。

      如果字段是ChronoField，则在此处实现查询。根据此时间，支持的字段将返回基于此时间的有效值，除了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，则在此处实现查询。基于此时间，支持的字段将返回有效值。所有其他ChronoField实例将抛出UnsupportedTemporalTypeException异常。

      如果字段不是ChronoField，则通过调用TemporalField.getFrom(TemporalAccessor)方法并将this作为参数来获取此方法的结果。值是否可以获取以及值代表什么由字段决定。

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

    • getOffset

      public ZoneOffset getOffset()
      获取区域偏移量，例如'+01:00'。

      这是本地时间与UTC/Greenwich之间的偏移量。

      返回值:
      区域偏移量，不能为空

    • withOffsetSameLocal

      public OffsetTime withOffsetSameLocal(ZoneOffset offset)
      返回具有指定偏移量的此OffsetTime的副本，确保结果具有相同的本地时间。

      此方法返回一个具有相同LocalTime和指定ZoneOffset的对象。不需要或执行任何计算。例如，如果此时间表示10:30+02:00，指定的偏移量为+03:00，则此方法将返回10:30+03:00。

      要考虑偏移量之间的差异并调整时间字段，请使用withOffsetSameInstant(java.time.ZoneOffset)。

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

      参数:
      offset - 要更改为的区域偏移量，不能为空
      返回值:
      基于此时间的OffsetTime，具有请求的偏移量，不能为空

    • withOffsetSameInstant

      public OffsetTime withOffsetSameInstant(ZoneOffset offset)
      返回具有指定偏移量的此OffsetTime的副本，确保结果在暗示的一天上处于相同的瞬间。

      此方法返回一个具有指定ZoneOffset和通过两个偏移量之间的差异调整的LocalTime的对象。这将导致旧对象和新对象在暗示的一天上表示相同的瞬间。这对于查找不同偏移量下的本地时间很有用。例如，如果此时间表示10:30+02:00，指定的偏移量为+03:00，则此方法将返回11:30+03:00。

      要更改偏移量而不调整本地时间，请使用withOffsetSameLocal(java.time.ZoneOffset)。

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

      参数:
      offset - 要更改为的区域偏移量，不能为空
      返回值:
      基于此时间的OffsetTime，具有请求的偏移量，不能为空

    • toLocalTime

      public LocalTime toLocalTime()
      获取此日期时间的LocalTime部分。

      返回一个LocalTime，其小时、分钟、秒和纳秒与此日期时间相同。

      返回值:
      此日期时间的时间部分，不能为空

    • 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 OffsetTime with(TemporalAdjuster adjuster)
      返回此时间的调整副本。

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

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

      类LocalTime和ZoneOffset实现了TemporalAdjuster，因此此方法可用于更改时间或偏移量：

        result = offsetTime.with(time);
  result = offsetTime.with(offset);

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

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

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

    • with

      public OffsetTime with(TemporalField field, long newValue)
      返回具有指定字段设置为新值的此时间的副本。

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

      如果字段是ChronoField，则在此处实现调整。

      OFFSET_SECONDS字段将返回具有指定偏移量的时间。本地时间不会改变。如果新的偏移量值超出有效范围，则会抛出DateTimeException异常。

      其他支持的字段将按照LocalTime.with(TemporalField, long) LocalTime}上的匹配方法的行为。在这种情况下，偏移量不是计算的一部分，将保持不变。

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

      如果字段不是ChronoField，则通过调用TemporalField.adjustInto(Temporal, long)方法并将this作为参数来获取此方法的结果。在这种情况下，字段确定是否以及如何调整时刻。

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

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

    • withHour

      public OffsetTime withHour(int hour)
      返回具有更改小时字段的此OffsetTime的副本。

      偏移量不影响计算，并且在结果中将保持不变。

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

      参数:
      hour - 要在结果中设置的小时，从0到23
      返回值:
      基于此时间的OffsetTime，具有请求的小时，不能为空
      抛出:
      DateTimeException - 如果小时值无效

    • withMinute

      public OffsetTime withMinute(int minute)
      返回具有更改小时数的此OffsetTime的副本。

      偏移量不影响计算，并且在结果中将保持不变。

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

      参数：
      minute - 要设置为结果的小时数，范围从0到59
      返回：
      基于此时间的OffsetTime，具有请求的小时数，非空
      抛出：
      DateTimeException - 如果小时数值无效

    • withSecond

      public OffsetTime withSecond(int second)
      返回具有更改分钟数的此OffsetTime的副本。

      偏移量不影响计算，并且在结果中将保持不变。

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

      参数：
      second - 要设置为结果的分钟数，范围从0到59
      返回：
      基于此时间的OffsetTime，具有请求的秒数，非空
      抛出：
      DateTimeException - 如果秒数值无效

    • withNano

      public OffsetTime withNano(int nanoOfSecond)
      返回具有更改纳秒数的此OffsetTime的副本。

      偏移量不影响计算，并且在结果中将保持不变。

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

      参数：
      nanoOfSecond - 要设置为结果的纳秒数，范围从0到999,999,999
      返回：
      基于此时间的OffsetTime，具有请求的纳秒数，非空
      抛出：
      DateTimeException - 如果纳秒值无效

    • truncatedTo

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

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

      单位必须具有可在标准日长度内被整除的持续时间。这包括所有提供的时间单位在ChronoUnit和DAYS上。其他单位会抛出异常。

      偏移量不影响计算，并且在结果中将保持不变。

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

      参数：
      unit - 要截断到的单位，非空
      返回：
      基于此时间的OffsetTime，具有截断的时间，非空
      抛出：
      DateTimeException - 如果无法截断
      UnsupportedTemporalTypeException - 如果不支持该单位

    • plus

      public OffsetTime plus(TemporalAmount amountToAdd)
      返回具有指定添加量的此时间的副本。

      这将返回一个OffsetTime，基于此时间，具有添加的指定量。该量通常是Duration，但也可以是实现TemporalAmount接口的任何其他类型。

      通过调用TemporalAmount.addTo(Temporal)将计算委托给量对象。量的实现可以以任何希望的方式实现添加，但通常会回调plus(long, TemporalUnit)。请查阅量实现的文档，以确定是否可以成功添加。

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

      指定者：
      plus 在接口 Temporal
      参数：
      amountToAdd - 要添加的量，非空
      返回：
      基于此时间的OffsetTime，具有进行的添加，非空
      抛出：
      DateTimeException - 如果无法进行添加
      ArithmeticException - 如果发生数值溢出

    • plus

      public OffsetTime plus(long amountToAdd, TemporalUnit unit)
      返回具有指定添加量的此时间的副本。

      这将返回一个OffsetTime，基于此时间，具有以单位为单位添加的量。如果无法添加该量，因为不支持该单位或出于其他原因，则会抛出异常。

      如果字段是ChronoUnit，则通过LocalTime.plus(long, TemporalUnit)实现添加。偏移量不是计算的一部分，并且在结果中将保持不变。

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

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

      指定者：
      plus 在接口 Temporal
      参数：
      amountToAdd - 要添加到结果的单位的量，可以为负数
      unit - 要添加的量的单位，非空
      返回：
      基于此时间的OffsetTime，具有添加的指定量，非空
      抛出：
      DateTimeException - 如果无法进行添加
      UnsupportedTemporalTypeException - 如果不支持该单位
      ArithmeticException - 如果发生数值溢出

    • plusHours

      public OffsetTime plusHours(long hours)
      返回具有指定小时数添加的此OffsetTime的副本。

      将指定的小时数添加到此时间，返回一个新时间。计算围绕午夜进行。

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

      参数：
      hours - 要添加的小时数，可以为负数
      返回：
      基于此时间的OffsetTime，具有添加的小时数，非空

    • plusMinutes

      public OffsetTime plusMinutes(long minutes)
      返回具有指定分钟数添加的此OffsetTime的副本。

      将指定的分钟数添加到此时间，返回一个新时间。计算围绕午夜进行。

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

      参数：
      minutes - 要添加的分钟数，可以为负数
      返回：
      基于此时间的OffsetTime，具有添加的分钟数，非空

    • plusSeconds

      public OffsetTime plusSeconds(long seconds)
      返回具有指定秒数添加的此OffsetTime的副本。

      将指定的秒数添加到此时间，返回一个新时间。计算围绕午夜进行。

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

      参数：
      seconds - 要添加的秒数，可以为负数
      返回：
      基于此时间的OffsetTime，具有添加的秒数，非空

    • plusNanos

      public OffsetTime plusNanos(long nanos)
      返回具有指定纳秒数添加的此OffsetTime的副本。

      将指定的纳秒数添加到此时间，返回一个新时间。计算围绕午夜进行。

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

      参数：
      nanos - 要添加的纳秒数，可以为负数
      返回：
      基于此时间的OffsetTime，具有添加的纳秒数，非空

    • minus

      public OffsetTime minus(TemporalAmount amountToSubtract)
      返回具有指定减去量的此时间的副本。

      这将返回一个OffsetTime，基于此时间，具有减去的指定量。该量通常是Duration，但也可以是实现TemporalAmount接口的任何其他类型。

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

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

      指定者：
      minus 在接口 Temporal
      参数：
      amountToSubtract - 要减去的量，非空
      返回：
      基于此时间的OffsetTime，具有进行的减法，非空
      抛出：
      DateTimeException - 如果无法进行减法
      ArithmeticException - 如果发生数值溢出

    • minus

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

      返回一个基于此时间的OffsetTime，其数量以单位为减去。如果无法减去数量，因为该单位不受支持或出现其他原因，则会抛出异常。

      此方法等效于使用带有相反数量的plus(long, TemporalUnit)。查看该方法以获取有关加法（因此也是减法）运作方式的完整描述。

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

      指定者：
      minus 在接口 Temporal
      参数：
      amountToSubtract - 要从结果中减去的单位数量，可以为负数
      unit - 要减去的数量的单位，不能为空
      返回：
      基于此时间的OffsetTime，减去指定数量后的结果，不能为空
      抛出：
      DateTimeException - 如果无法进行减法运算
      UnsupportedTemporalTypeException - 如果不支持该单位
      ArithmeticException - 如果发生数值溢出

    • minusHours

      public OffsetTime minusHours(long hours)
      返回减去指定小时数后的此OffsetTime的副本。

      从此时间减去指定小时数，返回一个新时间。计算会围绕午夜进行。

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

      参数：
      hours - 要减去的小时数，可以为负数
      返回：
      基于此时间的OffsetTime，减去小时数后的结果，不能为空

    • minusMinutes

      public OffsetTime minusMinutes(long minutes)
      返回减去指定分钟数后的此OffsetTime的副本。

      从此时间减去指定分钟数，返回一个新时间。计算会围绕午夜进行。

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

      参数：
      minutes - 要减去的分钟数，可以为负数
      返回：
      基于此时间的OffsetTime，减去分钟数后的结果，不能为空

    • minusSeconds

      public OffsetTime minusSeconds(long seconds)
      返回减去指定秒数后的此OffsetTime的副本。

      从此时间减去指定秒数，返回一个新时间。计算会围绕午夜进行。

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

      参数：
      seconds - 要减去的秒数，可以为负数
      返回：
      基于此时间的OffsetTime，减去秒数后的结果，不能为空

    • minusNanos

      public OffsetTime minusNanos(long nanos)
      返回减去指定纳秒数后的此OffsetTime的副本。

      从此时间减去指定纳秒数，返回一个新时间。计算会围绕午夜进行。

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

      参数：
      nanos - 要减去的纳秒数，可以为负数
      返回：
      基于此时间的OffsetTime，减去纳秒数后的结果，不能为空

    • 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和ChronoField.OFFSET_SECONDS作为字段。

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

         // 这两行是等效的，但推荐使用第二种方法
   temporal = thisOffsetTime.adjustInto(temporal);
   temporal = temporal.with(thisOffsetTime);

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

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

    • until

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

      计算两个OffsetTime对象之间的时间量，以单个TemporalUnit为单位。起始点和结束点是this和指定时间。如果结束在开始之前，则结果将为负数。例如，可以使用startTime.until(endTime, HOURS)来计算两个时间之间的小时数。

      传递给此方法的Temporal会使用from(TemporalAccessor)转换为OffsetTime。如果两个时间之间的偏移量不同，则会将指定的结束时间规范化为具有与此时间相同的偏移量。

      计算返回一个整数，表示两个时间之间的完整单位数。例如，在11:30Z和13:29Z之间的小时数只有一个小时，因为它比两个小时短一分钟。

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

         // 这两行是等效的
   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 - 结束时间（不包括），将其转换为OffsetTime，不能为空
      unit - 用于测量时间量的单位，不能为空
      返回：
      此时间和结束时间之间的时间量
      抛出：
      DateTimeException - 如果无法计算时间量，或者无法将结束时间转换为OffsetTime
      UnsupportedTemporalTypeException - 如果不支持该单位
      ArithmeticException - 如果发生数值溢出

    • format

      public String format(DateTimeFormatter formatter)
      使用指定的格式化程序格式化此时间。

      将此时间传递给格式化程序以生成一个字符串。

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

    • atDate

      public OffsetDateTime atDate(LocalDate date)
      将此时间与日期组合以创建一个OffsetDateTime。

      返回一个由此时间和指定日期形成的OffsetDateTime。所有日期和时间的可能组合都是有效的。

      参数:
      date - 要与之组合的日期，不能为空
      返回:
      从此时间和指定日期形成的偏移日期时间，不能为空

    • toEpochSecond

      public long toEpochSecond(LocalDate date)
      将此OffsetTime转换为自1970-01-01T00:00:00Z时代以来的秒数。

      这将此偏移时间与指定日期组合以计算时代秒值，即从1970-01-01T00:00:00Z以来经过的秒数。时代后的瞬间为正，之前为负。

      参数:
      date - 本地日期，不能为空
      返回:
      从1970-01-01T00:00:00Z时代以来的秒数，可能为负
      自:
      9

    • compareTo

      public int compareTo(OffsetTime other)
      将此OffsetTime与另一个时间进行比较。

      比较首先基于UTC等效瞬间，然后基于本地时间。它是“与equals一致”的，如Comparable中定义的那样。

      例如，以下是比较器顺序：

      1. 10:30+01:00
      2. 11:00+01:00
      3. 12:00+02:00
      4. 11:30+01:00
      5. 12:00+01:00
      6. 12:30+01:00
      值＃2和＃3代表时间线上的相同瞬间。当两个值代表相同瞬间时，将比较本地时间以区分它们。这一步骤是为了使排序与equals()一致。

      要比较两个TemporalAccessor实例的基础本地时间，请使用ChronoField.NANO_OF_DAY作为比较器。

      指定者:
      compareTo 在接口 Comparable<OffsetTime>
      参数:
      other - 要比较的另一个时间，不能为空
      返回:
      比较器值，即比较UTC等效other瞬间，如果它们不相等，并且如果UTC等效other瞬间相等，则比较此本地时间与other本地时间
      参见:

    • isAfter

      public boolean isAfter(OffsetTime other)
      检查此OffsetTime的瞬间是否在指定时间之后，将两个时间都应用于一个公共日期。

      此方法与compareTo(java.time.OffsetTime)中的比较不同，因为它仅比较时间的瞬间。这相当于使用相同日期将两个时间转换为瞬间并比较这些瞬间。

      参数:
      other - 要比较的另一个时间，不能为空
      返回:
      如果此时间在指定时间的瞬间之后，则为true

    • isBefore

      public boolean isBefore(OffsetTime other)
      检查此OffsetTime的瞬间是否在指定时间之前，将两个时间都应用于一个公共日期。

      此方法与compareTo(java.time.OffsetTime)中的比较不同，因为它仅比较时间的瞬间。这相当于使用相同日期将两个时间转换为瞬间并比较这些瞬间。

      参数:
      other - 要比较的另一个时间，不能为空
      返回:
      如果此时间在指定时间的瞬间之前，则为true

    • isEqual

      public boolean isEqual(OffsetTime other)
      检查此OffsetTime的瞬间是否等于指定时间的瞬间，将两个时间都应用于一个公共日期。

      此方法与compareTo(java.time.OffsetTime)和equals(java.lang.Object)中的比较不同，因为它仅比较时间的瞬间。这相当于使用相同日期将两个时间转换为瞬间并比较这些瞬间。

      参数:
      other - 要比较的另一个时间，不能为空
      返回:
      如果此时间等于指定时间的瞬间，则为true

    • equals

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

      比较基于本地时间和偏移量。要比较时间线上相同瞬间，请使用isEqual(OffsetTime)。

      仅比较OffsetTime类型的对象，其他类型返回false。要比较两个TemporalAccessor实例的基础本地时间，请使用ChronoField.NANO_OF_DAY作为比较器。

      覆盖:
      equals 在类 Object
      参数:
      obj - 要检查的对象，null返回false
      返回:
      如果此时间等于另一个时间，则为true
      参见:

    • hashCode

      public int hashCode()
      此时间的哈希码。
      覆盖:
      hashCode 在类 Object
      返回:
      适当的哈希码
      参见:

    • toString

      public String toString()
      将此时间输出为String，例如10:15:30+01:00。

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

      • HH:mmXXXXX
      • HH:mm:ssXXXXX
      • HH:mm:ss.SSSXXXXX
      • HH:mm:ss.SSSSSSXXXXX
      • HH:mm:ss.SSSSSSSSSXXXXX
      使用的格式将是输出完整时间值的最短格式，其中省略的部分被假定为零。
      覆盖:
      toString 在类 Object
      返回:
      此时间的字符串表示，不能为空