Module  java.base
软件包  java.time

Class OffsetTime

  • All Implemented Interfaces:
    SerializableComparable<OffsetTime>TemporalTemporalAccessorTemporalAdjuster


    public final class OffsetTime
    extends Object
    implements Temporal, TemporalAdjuster, Comparable<OffsetTime>, Serializable
    在ISO- 10:15:30+01:00 UTC /格林威治的时间,如10:15:30+01:00

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

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

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

      • MIN

        public static final OffsetTime MIN
        最低支持OffsetTime :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 - 要使用的时钟,不为空
        结果
        当前时间,不为null
      • 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 /格林威治的偏移量很简单,因为每个瞬间只有一个有效的偏移量。

        在转换期间,该瞬间的日期组件被丢弃。 这意味着转换永远不会因为瞬间超出有效的日期范围而失败。

        参数
        instant - 即时创建时间,不为null
        zone - 可能是偏移的时区,不为空
        结果
        偏移时间,不为空
      • from

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

        这获得了基于指定时间的偏移时间。 A 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 - 要解析的文本,不为空
        formatter - 要使用的格式化程序,不为null
        结果
        解析的偏移时间,不为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
        参数
        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作为参数。 设备是否受支持由本机决定。

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

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

        范围对象表示字段的最小和最大有效值。 这次用于提高返回范围的准确性。 如果不可能返回范围,因为该字段不受支持或出于某种其他原因,则抛出异常。

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

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

        Specified by:
        range在接口 TemporalAccessor
        参数
        field - 查询范围的字段,不为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在接口 TemporalAccessor
        参数
        field - 要获取的字段,不为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
        参数
        field - 要获取的字段,不为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基于这个时间与请求的偏移量,不为null
      • withOffsetSameInstant

        public OffsetTime withOffsetSameInstant​(ZoneOffset offset)
        返回具有指定偏移量的OffsetTime的副本,确保结果在隐含日期处于同一时刻。

        此方法返回一个具有指定的对象ZoneOffsetLocalTime由两个偏移之间的差异进行调整。 这将导致旧的和新的对象在默示的一天代表同一瞬间。 这对于在不同的偏移量中找到本地时间是有用的。 例如,如果此时间表示10:30+02:00并且指定的偏移量为+03:00 ,则此方法将返回11:30+03:00

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

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

        参数
        offset - 要更改的区域偏移量,不为空
        结果
        一个 OffsetTime基于此时间与请求的偏移量,不为null
      • toLocalTime

        public LocalTime toLocalTime​()
        获得这个日期时间的LocalTime部分。

        这将返回一个LocalTime与这个日期时间相同的小时,分,秒和纳秒。

        结果
        这个日期时间的一部分,不是null
      • 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); 

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

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

        Specified by:
        with在接口 Temporal
        参数
        adjuster - 调整器使用,不为空
        结果
        一个 OffsetTime基于 this进行了调整,不为null
        异常
        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
        参数
        field - 要在结果中设置的字段,不为null
        newValue - 结果中字段的新值
        结果
        一个 OffsetTime基于 this与指定的字段集,不为null
        异常
        DateTimeException - 如果该字段无法设置
        UnsupportedTemporalTypeException - 如果该字段不被支持
        ArithmeticException - 如果发生数字溢出
      • withHour

        public OffsetTime withHour​(int hour)
        返回此OffsetTime的副本,并更改日期。

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

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

        参数
        hour - 设置结果的时间从0到23
        结果
        一个 OffsetTime基于此时间与请求的小时,不为null
        异常
        DateTimeException - 如果小时值无效
      • withMinute

        public OffsetTime withMinute​(int minute)
        返回此OffsetTime的副本,小时更改。

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

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

        参数
        minute - 结果中设置的小时从0到59
        结果
        一个 OffsetTime基于此时间与请求的分钟,不为null
        异常
        DateTimeException - 如果分钟值无效
      • withSecond

        public OffsetTime withSecond​(int second)
        返回此OffsetTime的副本,其中第二分钟更改。

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

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

        参数
        second - 在0到59之间设置结果的 second
        结果
        一个 OffsetTime基于此时与请求的第二个,不为null
        异常
        DateTimeException - 如果第二个值无效
      • withNano

        public OffsetTime withNano​(int nanoOfSecond)
        返回这个OffsetTime的副本, OffsetTime改变了。

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

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

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

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

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

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

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

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

        参数
        unit - 截断到的单位,不为null
        结果
        一个 OffsetTime基于此时间截断,不为null
        异常
        DateTimeException - 如果无法截断
        UnsupportedTemporalTypeException - 如果不支持本机
      • plus

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

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

        通过调用TemporalAmount.addTo(Temporal)将计算委托给金额对象。 数量执行可以以任何方式实现添加,但是它通常会调用到plus(long, TemporalUnit) 请参阅金额执行的文档,以确定是否可以成功添加。

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

        Specified by:
        plus在接口 Temporal
        参数
        amountToAdd - 要添加的金额,不为null
        结果
        一个 OffsetTime基于这个时间与添加,而不是null
        异常
        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 - 要添加的单位,不为null
        结果
        一个 OffsetTime基于这个时间与指定的数量添加,不为null
        异常
        DateTimeException - 如果不能添加
        UnsupportedTemporalTypeException - 如果不支持本机
        ArithmeticException - 如果发生数字溢出
      • plusHours

        public OffsetTime plusHours​(long hours)
        返回此OffsetTime的副本,并附加指定的小时数。

        这样就增加了指定的小时数,返回一个新的时间。 计算周期在午夜。

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

        参数
        hours - 要添加的时间可能为负数
        结果
        一个 OffsetTime基于这个时间加上小时,不为null
      • plusMinutes

        public OffsetTime plusMinutes​(long minutes)
        以指定的分钟数返回此OffsetTime的副本。

        这样就添加了指定的分钟数,返回一个新的时间。 计算周期在午夜。

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

        参数
        minutes - 要添加的分钟,可能为负数
        结果
        一个 OffsetTime基于这个时间加上分钟,不为null
      • plusSeconds

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

        这样就增加了指定的秒数,返回一个新的时间。 计算周期在午夜。

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

        参数
        seconds - 添加的秒数可能为负数
        结果
        一个 OffsetTime基于这个时间与秒添加,不为null
      • plusNanos

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

        这样就增加了指定的纳秒数,返回一个新的时间。 计算周期在午夜。

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

        参数
        nanos - nanos添加,可能为负
        结果
        一个 OffsetTime基于这个时间加上纳秒,不为null
      • minus

        public OffsetTime minus​(TemporalAmount amountToSubtract)
        返回此次的副本,减去指定的金额。

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

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

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

        Specified by:
        minus在接口 Temporal
        参数
        amountToSubtract - 减去量,不为空
        结果
        一个 OffsetTime基于这个时间与减法而不是null
        异常
        DateTimeException - 如果不能进行减法
        ArithmeticException - 如果发生数字溢出
      • minus

        public OffsetTime minus​(long amountToSubtract,
                                TemporalUnit unit)
        返回此次的副本,减去指定的金额。

        这将返回一个OffsetTime ,基于这一个,减去的单位数量。 如果不可能减去金额,因为该单位不受支持或出于某种其他原因,则会抛出异常。

        该方法相当于plus(long, TemporalUnit) ,数量被否定。 请参阅该方法,以了解如何添加,从而减去运算。

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

        Specified by:
        minus在接口 Temporal
        参数
        amountToSubtract - 从结果中减去单位的数量可能为负数
        unit - 减去量的单位,不为空
        结果
        一个 OffsetTime基于此时间减去指定的数量,不为null
        异常
        DateTimeException - 如果不能进行减法
        UnsupportedTemporalTypeException - 如果不支持本机
        ArithmeticException - 如果发生数字溢出
      • minusHours

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

        这样从这个时间减去指定的小时数,返回一个新的时间。 计算周期在午夜。

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

        参数
        hours - 减去的时间可能为负数
        结果
        一个 OffsetTime基于此时间减去的小时数,不为空
      • minusMinutes

        public OffsetTime minusMinutes​(long minutes)
        以指定的分钟数减去此OffsetTime的副本。

        这将从此时间减去指定的分钟数,返回一个新的时间。 计算周期在午夜。

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

        参数
        minutes - 减去的分数可能为负数
        结果
        一个 OffsetTime基于此时间减去了分数,不为null
      • 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(由查询定义)
        异常
        DateTimeException - 如果无法查询(由查询定义)
        ArithmeticException - 如果发生数字溢出(由查询定义)
      • until

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

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

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

        计算返回一个整数,表示两次之间的完整单位数。 例如,11:30Z至13:29Z之间的小时数将仅为1小时,为2分钟不到2分钟。

        使用这种方法有两种等效的方法。 第一个是调用这个方法。 二是使用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
        结果
        格式化的时间字符串,不为null
        异常
        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 - 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作为比较器。

        重写:
        equalsObject
        参数
        obj - 要检查的对象,null返回false
        结果
        如果这等于其他时间,则为真
        另请参见:
        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
        所使用的格式将是将省略部分隐含为零的时间的全部值输出的最短。
        重写:
        toStringObject
        结果
        这个时间的字符串表示,不为null