模块  java.base
软件包  java.time

Class OffsetTime

  • 实现的所有接口
    SerializableComparable<OffsetTime>TemporalTemporalAccessorTemporalAdjuster

    public final class OffsetTime
    extends Object
    implements Temporal, TemporalAdjuster, Comparable<OffsetTime>, Serializable
    在ISO- 10:15:30+01:00 UTC / Greenwich偏移的时间,例如10:15:30+01:00

    OffsetTime是一个不可变的日期时间对象,表示一个时间,通常被视为小时 - 秒 - 秒偏移量。 此类存储所有时间字段,精度为纳秒,以及区域偏移。 例如,值“13:45:30.123456789 + 02:00”可以存储在OffsetTime

    这是一个value-based班; OffsetTime实例上使用身份敏感操作(包括引用相等( == ),标识哈希码或同步)可能会产生不可预测的结果,应该避免使用。 equals方法应该用于比较。

    实现要求:
    这个类是不可变的和线程安全的。
    从以下版本开始:
    1.8
    另请参见:
    Serialized Form
    • 字段详细信息

      • MIN

        public static final OffsetTime MIN
        最低支持OffsetTime ,'00:00:00 + 18:00'。 这是在最大偏移量的一天开始的午夜时间(较大的偏移在时间线上较早)。 它结合了LocalTime.MINZoneOffset.MAX 这可以被应用程序用作“远期”日期。
      • MAX

        public static final OffsetTime MAX
        支持的最大值为OffsetTime ,'23:59:59.999999999-18:00'。 这是在一天结束时午夜之前的最小偏移量的时间(较大的负偏移量稍后在时间线上)。 它结合了LocalTime.MAXZoneOffset.MIN 这可以被应用程序用作“远期未来”日期。
    • 方法详细信息

      • now

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

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

        使用此方法将无法使用备用时钟进行测试,因为时钟是硬编码的。

        结果
        使用系统时钟和默认时区的当前时间,不为空
      • now

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

        这将查询system clock以获取当前时间。 指定时区可避免依赖于默认时区。 偏移量将从指定的时区计算。

        使用此方法将无法使用备用时钟进行测试,因为时钟是硬编码的。

        参数
        zone - 要使用的区域ID,不为空
        结果
        使用系统时钟的当前时间,不为空
      • now

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

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

        使用此方法允许使用备用时钟进行测试。 可以使用dependency injection引入备用时钟。

        参数
        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 - 创建时间的瞬间,而不是null
        zone - 时区,可以是偏移量,不为空
        结果
        偏移时间,不为空
      • from

        public static OffsetTime from​(TemporalAccessor temporal)
        从时态对象获得OffsetTime的实例。

        这基于指定的时间获得偏移时间。 TemporalAccessor表示一组任意日期和时间信息,该工厂将其转换为OffsetTime的实例。

        转换从时态对象中提取并组合ZoneOffsetLocalTime 允许实现执行优化,例如访问与相关对象等效的那些字段。

        此方法匹配功能接口TemporalQuery的签名,允许通过方法引用OffsetTime::from将其用作查询。

        参数
        temporal - 要转换的时态对象,而不是null
        结果
        偏移时间,不为空
        异常
        DateTimeException - 如果无法转换为 OffsetTime
      • parse

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

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

        参数
        text - 要解析的文本,例如“ text + 01:00”,不为空
        结果
        解析的本地时间,不为空
        异常
        DateTimeParseException - 如果无法解析文本
      • parse

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

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

        参数
        text - 要解析的文本,而不是null
        formatter - 要使用的格式化程序,不为null
        结果
        解析的偏移时间,不为空
        异常
        DateTimeParseException - 如果无法解析文本
      • isSupported

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

        这将检查是否可以查询指定字段的时间。 如果是假,然后调用rangegetwith(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作为参数来获得此方法的结果。 字段是否受支持由字段确定。

        Specified by:
        isSupported在界面 TemporalAccessor
        参数
        字段 - 要检查的字段,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作为参数。 设备是否受支持由设备决定。

        Specified by:
        isSupported在界面 Temporal
        参数
        unit - 要检查的单位,null返回false
        结果
        如果可以添加/减去单位,则为true,否则为false
      • range

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

        范围对象表示字段的最小和最大有效值。 此时间用于提高返回范围的准确性。 如果无法返回范围,因为不支持该字段或由于某些其他原因,将引发异常。

        如果该字段是ChronoField则在此处执行查询。 supported fields将返回适当的范围实例。 所有其他ChronoField实例将抛出UnsupportedTemporalTypeException

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

        Specified by:
        range在界面 TemporalAccessor
        参数
        字段 - 要查询范围的字段,而不是null
        结果
        字段的有效值范围,不为null
        异常
        DateTimeException - 如果无法获得该字段的范围
        UnsupportedTemporalTypeException - 如果不支持该字段
      • get

        public int get​(TemporalField field)
        int获取此时指定字段的值。

        这次查询指定字段的值。 返回的值将始终在该字段的有效值范围内。 如果无法返回该值,因为不支持该字段或由于某些其他原因,将引发异常。

        如果该字段是ChronoField则在此处实现查询。 supported fields将根据此时间返回有效值,但NANO_OF_DAYMICRO_OF_DAY除外,它们太大而无法放入int并抛出UnsupportedTemporalTypeException 所有其他ChronoField实例将抛出UnsupportedTemporalTypeException

        如果该字段是不是一个ChronoField ,则此方法的结果是通过调用获得TemporalField.getFrom(TemporalAccessor)传递this作为参数。 是否可以获得该值以及该值表示的值由该字段确定。

        Specified by:
        get in interface TemporalAccessor
        参数
        字段 - 要获取的字段,而不是null
        结果
        该字段的值
        异常
        DateTimeException - 如果无法获取该字段的值或该值超出该字段的有效值范围
        UnsupportedTemporalTypeException - 如果不支持该字段或值的范围超过 int
        ArithmeticException - 如果发生数字溢出
      • getLong

        public long getLong​(TemporalField field)
        long获取此时指定字段的值。

        这次查询指定字段的值。 如果无法返回该值,因为不支持该字段或由于某些其他原因,将引发异常。

        如果该字段是ChronoField则在此处实现查询。 supported fields将根据此时间返回有效值。 所有其他ChronoField实例将抛出UnsupportedTemporalTypeException

        如果该字段是不是一个ChronoField ,则此方法的结果是通过调用获得TemporalField.getFrom(TemporalAccessor)传递this作为参数。 是否可以获得该值以及该值表示的值由该字段确定。

        Specified by:
        getLong在界面 TemporalAccessor
        参数
        字段 - 要获取的字段,而不是null
        结果
        该字段的值
        异常
        DateTimeException - 如果无法获取该字段的值
        UnsupportedTemporalTypeException - 如果不支持该字段
        ArithmeticException - 如果发生数字溢出
      • getOffset

        public ZoneOffset getOffset()
        获取区域偏移量,例如“+01:00”。

        这是当地时间与UTC /格林威治的偏移量。

        结果
        区域偏移,不为空
      • 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的副本,确保结果在隐含日期的同一时刻。

        此方法返回具有指定的ZoneOffsetLocalTime的对象,并通过两个偏移之间的差异进行调整。 这将导致旧的和新的对象在隐含的一天表示相同的瞬间。 这对于在不同偏移中查找本地时间很有用。 例如,如果此时间表示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 ,基于此,调整时间。 使用指定的调整器策略对象进行调整。 阅读调整器的文档,了解将进行哪些调整。

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

        LocalTimeZoneOffset实现TemporalAdjuster ,因此此方法可用于更改时间或偏移量:

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

        此方法的结果是通过调用获得TemporalAdjuster.adjustInto(Temporal)在经过指定的调节方法this作为参数。

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

        Specified by:
        with在界面 Temporal
        参数
        adjuster - 要使用的调整器,不为null
        结果
        一个 OffsetTime基于 this与制造,不为空调整
        异常
        DateTimeException - 如果无法进行调整
        ArithmeticException - 如果发生数字溢出
      • with

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

        这将返回OffsetTime (基于此值),并更改指定字段的值。 这可用于更改任何支持的字段,例如小时,分钟或秒。 如果无法设置该值,因为不支持该字段或由于某些其他原因,将引发异常。

        如果该字段是ChronoField则在此处执行调整。

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

        另一个supported fields将按照LocalTime.with(TemporalField, long) LocalTime }上的匹配方法运行 在这种情况下,偏移量不是计算的一部分,并且不会改变。

        所有其他ChronoField实例将抛出UnsupportedTemporalTypeException

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

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

        Specified by:
        with在界面 Temporal
        参数
        字段 - 要在结果中设置的字段,不为空
        newValue - 结果中字段的新值
        结果
        一个 OffsetTime基于 this使用指定的字段设置,不为空
        异常
        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 - 在结果中设置的 second ,从0到59
        结果
        基于此时间的 OffsetTime与请求的秒,不为空
        异常
        DateTimeException - 如果第二个值无效
      • withNano

        public OffsetTime withNano​(int nanoOfSecond)
        返回此OffsetTime的副本,并更改了纳秒。

        偏移量不会影响计算,结果也相同。

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

        参数
        nanoOfSecond - 在结果中设置的纳秒数,从0到999,999,999
        结果
        基于此时间的 OffsetTime ,请求纳秒,不为空
        异常
        DateTimeException - 如果nanos值无效
      • truncatedTo

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

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

        该单位必须有一个duration ,分为标准日的长度,没有余数。 这包括ChronoUnitDAYS上提供的所有时间单位。 其他单位抛出异常。

        偏移量不会影响计算,结果也相同。

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

        参数
        unit - 要截断的单位,而不是null
        结果
        基于此时间的 OffsetTime ,截断时间,不为空
        异常
        DateTimeException - 如果无法截断
        UnsupportedTemporalTypeException - 如果不支持该装置
      • plus

        public OffsetTime plus​(TemporalAmount amountToAdd)
        返回此时间的副本,并添加指定的数量。

        这将返回基于此值的OffsetTime ,并添加指定的量。 金额通常为Duration但可以是实现TemporalAmount界面的任何其他类型。

        通过调用TemporalAmount.addTo(Temporal)将计算委托给amount对象。 实施金额可以任意方式自由实施,但通常会回拨plus(long, TemporalUnit) 请参阅金额实施的文档,以确定是否可以成功添加。

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

        Specified by:
        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作为参数。 在这种情况下,该单元确定是否以及如何执行添加。

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

        Specified by:
        plus在界面 Temporal
        参数
        amountToAdd - 要添加到结果中的单位数量可能为负数
        unit - 要添加的金额的单位,而不是空
        结果
        基于此时间的 OffsetTime ,添加了指定的金额,而不是null
        异常
        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的副本, OffsetTime添加了指定的纳秒数。

        这会在此时添加指定的纳秒数,从而返回新的时间。 计算在午夜左右。

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

        参数
        nanos - 要添加的 nanos ,可能是负面的
        结果
        基于此时间的 OffsetTime ,加上纳秒,不为空
      • minus

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

        这将返回一个OffsetTime ,基于此值,减去指定的数量。 金额通常为Duration但可以是实现TemporalAmount接口的任何其他类型。

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

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

        Specified by:
        minus在界面 Temporal
        参数
        amountToSubtract - 要减去的金额,而不是空
        结果
        基于此时间的 OffsetTime进行减法,而不是空
        异常
        DateTimeException - 如果无法进行减法
        ArithmeticException - 如果发生数字溢出
      • minus

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

        这将返回一个OffsetTime ,基于此,减去单位的数量。 如果无法减去金额,因为不支持该单位或由于某些其他原因,则抛出异常。

        该方法相当于plus(long, TemporalUnit) ,其数量为负数 有关添加和减法如何工作的完整描述,请参阅该方法。

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

        Specified by:
        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 - 要减去的 nanos ,可能是负的
        结果
        基于此时间的 OffsetTime减去纳秒,而不是空
      • query

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

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

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

        Specified by:
        query在界面 TemporalAccessor
        参数类型
        R - 结果的类型
        参数
        query - 要调用的查询,而不是null
        结果
        查询结果,可以返回null(由查询定义)
        异常
        DateTimeException - 如果无法查询(由查询定义)
        ArithmeticException - 如果发生数字溢出(由查询定义)
      • adjustInto

        public Temporal adjustInto​(Temporal temporal)
        调整指定的时态对象,使其具有与此对象相同的偏移量和时间。

        这将返回与输入相同的可观察类型的时间对象,其中偏移量和时间更改为与此相同。

        调整相当于使用Temporal.with(TemporalField, long)两次,通过ChronoField.NANO_OF_DAYChronoField.OFFSET_SECONDS作为字段。

        在大多数情况下,使用Temporal.with(TemporalAdjuster)更清楚地反转调用模式:

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

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

        Specified by:
        adjustInto ,接口 TemporalAdjuster
        参数
        temporal - 要调整的目标对象,而不是null
        结果
        调整后的对象,不为空
        异常
        DateTimeException - 如果无法进行调整
        ArithmeticException - 如果发生数字溢出
      • until

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

        这将根据单个TemporalUnit计算两个OffsetTime对象之间的时间量。 起点和终点是this和指定的时间。 如果结束在开始之前,结果将是否定的。 例如,可以使用startTime.until(endTime, HOURS)计算两次之间的小时startTime.until(endTime, HOURS)

        所述Temporal传递给此方法被转换为OffsetTime使用from(TemporalAccessor) 如果偏移量在两次之间不同,则指定的结束时间被标准化为具有与此时相同的偏移量。

        计算返回一个整数,表示两次之间的完整单位数。 例如,11:30Z和13:29Z之间的小时数仅为1小时,因为它是两小时的一分钟。

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

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

        计算在ChronoUnit此方法中实现 单位NANOSMICROSMILLISSECONDSMINUTESHOURSHALF_DAYS支持。 其他ChronoUnit值将引发异常。

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

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

        Specified by:
        until ,接口 Temporal
        参数
        endExclusive - 结束时间,不包括,转换为 OffsetTime ,不为空
        unit - 计量金额的单位,而不是空
        结果
        此时间与结束时间之间的时间量
        异常
        DateTimeException - 如果金额无法计算,或结束时间不能转换为 OffsetTime
        UnsupportedTemporalTypeException - 如果不支持该装置
        ArithmeticException - 如果发生数字溢出
      • format

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

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

        参数
        formatter - 要使用的格式化程序,而不是null
        结果
        格式化的时间字符串,不为空
        异常
        DateTimeException - 如果在打印期间发生错误
      • atDate

        public OffsetDateTime atDate​(LocalDate date)
        将此时间与日期相结合以创建OffsetDateTime

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

        参数
        date - 要结合的日期,而不是null
        结果
        从此时间和指定日期形成的偏移日期时间,不为空
      • toEpochSecond

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

        这将此偏移时间与指定日期组合以计算纪元秒值,该值是1970-01-01T00:00:00Z的经过秒数。 在时代之后的时间线上的实例是正的,之前是负的。

        参数
        date - localdate,not null
        结果
        自1970-01-01T00:00:00Z时代以来的秒数可能是负数
        从以下版本开始:
        9
      • compareTo

        public int compareTo​(OffsetTime other)
        比较这个OffsetTime到另一个时间。

        比较首先基于UTC等效时刻,然后是当地时间。 它与“等于”一致,如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作为比较器。

        Specified by:
        compareTo ,界面 Comparable<OffsetTime>
        参数
        other - 另一个要比较的时间,而不是null
        结果
        比较器值,如果更小则为负,如果更大则为正
      • isAfter

        public boolean isAfter​(OffsetTime other)
        检查此OffsetTime的瞬间是否在指定时间之后,同时应用于共同日期。

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

        参数
        other - 要比较的另一个时间,而不是null
        结果
        如果这是在指定时间的瞬间之后,则为true
      • isBefore

        public boolean isBefore​(OffsetTime other)
        检查此OffsetTime的瞬间是否在指定时间之前,同时将两次应用于共同日期。

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

        参数
        other - 要比较的另一个时间,而不是null
        结果
        如果这是在指定时间的瞬间之前,则为true
      • isEqual

        public boolean isEqual​(OffsetTime other)
        检查此OffsetTime的瞬间是否等于指定时间的瞬间同时应用于共同日期。

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

        参数
        other - 要比较的另一个时间,而不是null
        结果
        如果它等于指定时间的瞬间,则返回true
      • equals

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

        比较基于本地时间和偏移量。 要比较时间线上的同一时刻,请使用isEqual(OffsetTime)

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

        重写:
        equals ,课程 Object
        参数
        obj - 要检查的对象,null返回false
        结果
        如果这等于另一个时间,则为true
        另请参见:
        Object.hashCode()HashMap
      • 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
        结果
        此时的字符串表示形式,不为null