模块 java.base

包 java.time

类 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 
      

与 ISO-8601 日历系统中的 UTC/Greenwich 有偏移的时间，例如 10:15:30+01:00 。

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

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

实现要求：

这个类是不可变的和线程安全的。

自从：

1.8

参见：

• Serialized Form

字段摘要

字段

修饰符和类型	Field	描述
static final OffsetTime	MAX	最大支持 OffsetTime ，'23:59:59.999999999-18:00'。
static final OffsetTime	MIN	支持的最小值 OffsetTime，'00:00:00+18:00'。

方法总结

修饰符和类型	方法	描述
Temporal	adjustInto(Temporal temporal)	将指定的时间对象调整为与此对象具有相同的偏移量和时间。
OffsetDateTime	atDate(LocalDate date)	将这个时间与日期结合起来创建一个 OffsetDateTime 。
int	compareTo(OffsetTime other)	将这个 OffsetTime 与另一个时间进行比较。
boolean	equals(Object obj)	检查这个时间是否等于另一个时间。
String	format(DateTimeFormatter formatter)	这次使用指定的格式化程序进行格式化。
static OffsetTime	from(TemporalAccessor temporal)	从时间对象中获取 OffsetTime 的实例。
int	get(TemporalField field)	从此时开始获取指定字段的值作为 int 。
int	getHour()	获取一天中的小时字段。
long	getLong(TemporalField field)	从此时开始获取指定字段的值作为 long 。
int	getMinute()	获取分钟字段。
int	getNano()	获取纳秒级字段。
ZoneOffset	getOffset()	获取区域偏移量，例如“+01:00”。
int	getSecond()	获取秒字段。
int	hashCode()	这次的哈希码。
boolean	isAfter(OffsetTime other)	检查此 OffsetTime 的时刻是否在指定时间的时刻之后，将这两个时间应用到一个公共日期。
boolean	isBefore(OffsetTime other)	检查此 OffsetTime 的时刻是否早于将这两个时间应用到一个公共日期的指定时间的时刻。
boolean	isEqual(OffsetTime other)	检查此 OffsetTime 的时刻是否等于指定时间的时刻，将这两个时间应用到一个公共日期。
boolean	isSupported(TemporalField field)	检查是否支持指定的字段。
boolean	isSupported(TemporalUnit unit)	检查是否支持指定的单位。
OffsetTime	minus(long amountToSubtract, TemporalUnit unit)	返回此时间的副本，并减去指定的数量。
OffsetTime	minus(TemporalAmount amountToSubtract)	返回此时间的副本，并减去指定的数量。
OffsetTime	minusHours(long hours)	返回此 OffsetTime 的副本，并减去指定的小时数。
OffsetTime	minusMinutes(long minutes)	返回此 OffsetTime 的副本，并减去指定的分钟数。
OffsetTime	minusNanos(long nanos)	返回此 OffsetTime 的副本，并减去指定的纳秒数。
OffsetTime	minusSeconds(long seconds)	返回此 OffsetTime 的副本，并减去指定的秒数。
static OffsetTime	now()	从默认时区的系统时钟获取当前时间。
static OffsetTime	now(Clock clock)	从指定时钟获取当前时间。
static OffsetTime	now(ZoneId zone)	从指定时区的系统时钟获取当前时间。
static OffsetTime	of(int hour, int minute, int second, int nanoOfSecond, ZoneOffset offset)	从小时、分钟、秒和纳秒中获取 OffsetTime 的实例。
static OffsetTime	of(LocalTime time, ZoneOffset offset)	从本地时间和偏移量获取 OffsetTime 的实例。
static OffsetTime	ofInstant(Instant instant, ZoneId zone)	从 Instant 和区域 ID 获取 OffsetTime 的实例。
static OffsetTime	parse(CharSequence text)	从 10:15:30+01:00 等文本字符串中获取 OffsetTime 的实例。
static OffsetTime	parse(CharSequence text, DateTimeFormatter formatter)	使用特定格式化程序从文本字符串中获取 OffsetTime 的实例。
OffsetTime	plus(long amountToAdd, TemporalUnit unit)	返回添加了指定数量的此时间的副本。
OffsetTime	plus(TemporalAmount amountToAdd)	返回添加了指定数量的此时间的副本。
OffsetTime	plusHours(long hours)	返回此 OffsetTime 的副本，其中添加了指定的小时数。
OffsetTime	plusMinutes(long minutes)	返回此 OffsetTime 的副本，并添加了指定的分钟数。
OffsetTime	plusNanos(long nanos)	返回此 OffsetTime 的副本，并添加了指定的纳秒数。
OffsetTime	plusSeconds(long seconds)	返回此 OffsetTime 的副本，并添加了指定的秒数。
<R> R	query(TemporalQuery<R> query)	这次查询使用指定的查询。
ValueRange	range(TemporalField field)	获取指定字段的有效值范围。
long	toEpochSecond(LocalDate date)	将此 OffsetTime 转换为自 1970-01-01T00:00:00Z 纪元以来的秒数。
LocalTime	toLocalTime()	获取此日期时间的 LocalTime 部分。
String	toString()	这次输出为 String ，例如 10:15:30+01:00 。
OffsetTime	truncatedTo(TemporalUnit unit)	返回此 OffsetTime 的副本，时间被截断。
long	until(Temporal endExclusive, TemporalUnit unit)	根据指定的单位计算到另一个时间为止的时间量。
OffsetTime	with(TemporalAdjuster adjuster)	返回此时间的调整副本。
OffsetTime	with(TemporalField field, long newValue)	返回此时间的副本，并将指定字段设置为新值。
OffsetTime	withHour(int hour)	返回此 OffsetTime 的副本，其中更改了一天中的小时数。
OffsetTime	withMinute(int minute)	返回此 OffsetTime 的副本，并更改了分钟。
OffsetTime	withNano(int nanoOfSecond)	返回此 OffsetTime 的副本，并更改了纳秒级。
OffsetTime	withOffsetSameInstant(ZoneOffset offset)	返回具有指定偏移量的此 OffsetTime 的副本，确保结果在隐含日期的同一时刻。
OffsetTime	withOffsetSameLocal(ZoneOffset offset)	返回具有指定偏移量的此 OffsetTime 的副本，确保结果具有相同的本地时间。
OffsetTime	withSecond(int second)	返回此 OffsetTime 的副本，并更改了秒数。

在类 java.lang.Object 中声明的方法

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

字段详细信息

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 。这可以被应用程序用作“遥远的未来”日期。

方法详情

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/格林威治的偏移量很简单，因为每个时刻只有一个有效偏移量。

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

参数：

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 那么查询就在这里实现。 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 - 如果发生数字溢出

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 的副本，确保结果在隐含日期的同一时刻。

此方法返回一个对象，该对象具有指定的 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 - 要使用的调节器，不为空

返回：

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 作为参数来获得此方法的结果。在这种情况下，该字段决定是否以及如何调整瞬间。

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

指定者：

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 单位截断会将秒和纳秒字段设置为零。

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

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

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

参数：

unit - 要截断的单位，不为空

返回：

一个 OffsetTime 基于这个时间被截断的时间，不为空

抛出：

DateTimeException - 如果无法截断

UnsupportedTemporalTypeException - 如果不支持该单元

plus

public OffsetTime  plus(TemporalAmount  amountToAdd)
            

返回添加了指定数量的此时间的副本。

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

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

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

指定者：

plus 在接口 Temporal 中

参数：

amountToAdd - 添加的数量，不为空

返回：

an 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) 。查阅 amount 实现的文档以确定是否可以成功减去。

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

指定者：

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) 反转调用模式会更清楚：

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

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

指定者：

adjustInto 在接口 TemporalAdjuster 中

参数：

temporal - 要调整的目标对象，不为空

返回：

调整后的对象，不为空

抛出：

DateTimeException - 如果无法进行调整

ArithmeticException - 如果发生数字溢出

until

public long until(Temporal  endExclusive, TemporalUnit  unit)
            

根据指定的单位计算到另一个时间为止的时间量。

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

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

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

有两种等效的方法可以使用此方法。第一个是调用这个方法。第二种是使用 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 - 结束时间，独占，转换为 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 等效时刻，然后基于本地时间。正如 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 - 另一个要比较的时间，不为空

返回：

比较值，小于则为负，大于则为正

isAfter

public boolean isAfter(OffsetTime  other)
            

检查此 OffsetTime 的时刻是否在指定时间的时刻之后，将这两个时间应用到一个公共日期。

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

参数：

other - 另一个要比较的时间，不为空

返回：

如果这是在指定时间的瞬间之后，则为真

isBefore

public boolean isBefore(OffsetTime  other)
            

检查此 OffsetTime 的时刻是否早于将这两个时间应用到一个公共日期的指定时间的时刻。

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

参数：

other - 另一个要比较的时间，不为空

返回：

如果这是在指定时间的瞬间之前，则为真

isEqual

public boolean isEqual(OffsetTime  other)
            

检查此 OffsetTime 的时刻是否等于指定时间的时刻，将这两个时间应用到一个公共日期。

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

参数：

other - 另一个要比较的时间，不为空

返回：

如果这等于指定时间的瞬间，则为真

equals

public boolean equals(Object  obj)
            

检查这个时间是否等于另一个时间。

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

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

重写：

equals 在类 Object 中

参数：

obj - 要检查的对象，null 返回 false

返回：

如果这等于其他时间，则为真

参见：

• Object.hashCode()
• HashMap

hashCode

public int hashCode()
            

这次的哈希码。

重写：

hashCode 在类 Object 中

返回：

合适的哈希码

参见：

• Object.equals(java.lang.Object)
• System.identityHashCode(java.lang.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 中

返回：

这次的字符串表示形式，不为空