模块 java.base

包 java.time

类 Instant

java.lang.Object

java.time.Instant

所有已实现的接口：

Serializable , Comparable<Instant> , Temporal , TemporalAccessor , TemporalAdjuster

public final class Instant extends Object implements Temporal , TemporalAdjuster , Comparable <Instant >, Serializable 
      

时间线上的一个瞬时点。

此类对时间线上的单个瞬时点进行建模。这可能用于记录应用程序中的事件时间戳。

瞬间的范围需要存储大于 long 的数字。为实现这一点，该类存储了一个代表纪元秒的 long 和一个代表纳秒的 int，它们始终在 0 到 999,999,999 之间。历元秒是从 1970-01-01T00:00:00Z 的标准 Java 纪元开始测量的，其中纪元之后的瞬间具有正值，而更早的瞬间具有负值。对于纪元秒和纳秒部分，较大的值总是在时间线上比较小的值晚。

Time-scale

太阳日的长度是人类测量时间的标准方式。这在传统上被细分为 24 小时 60 分 60 秒，形成 86400 秒。

现代计时基于原子钟，原子钟精确定义了相对于铯原子跃迁的 SI 秒。 SI 秒的长度被定义为非常接近一天的第 86400 个分数。

不幸的是，随着地球自转，一天的长度会发生变化。此外，随着时间的推移，一天的平均长度随着地球减速而变长。因此，2012 年一个太阳日的长度略长于 86400 SI 秒。任何给定一天的实际长度和地球减速的量是不可预测的，只能通过测量来确定。 UT1 时间刻度捕捉准确的一天长度，但仅在一天结束后的某个时间可用。

UTC 时标是一种标准方法，用于将 UT1 中所有额外的几分之一秒合并为整秒，称为闰秒.根据地球自转的变化，可能会添加或删除闰秒。因此，UTC 允许一天有 86399 SI 秒或 86401 SI 秒，以保持一天与太阳对齐。

现代 UTC 时标于 1972 年推出，引入了整闰秒的概念。 1958 年至 1972 年间，UTC 的定义很复杂，有微小的亚秒级跳跃和对假想秒的长度的更改。截至 2012 年，正在讨论再次更改 UTC 的定义，可能会删除闰秒或引入其他更改。

鉴于上述精确计时的复杂性，此 Java API 定义了自己的时间尺度，即Java 时标.

Java Time-Scale 将每个日历日精确划分为 86400 个细分，称为秒。这些秒数可能与 SI 秒数不同。它与事实上的国际民用时标非常吻合，其定义不时发生变化。

Java Time-Scale 对时间线的不同部分的定义略有不同，每个部分都基于用作民用时间基础的共识国际时间尺度。每当修改或替换国际商定的时标时，都必须为其定义新的 Java 时标段。每个部分都必须满足以下要求：

• Java时标应与基本的国际民用时标紧密匹配；
• Java时标应与每天中午的国际民用时标完全匹配；
• Java时标应与国际民用时标有精确定义的关系。

目前，截至 2013 年，Java 时间尺度分为两个部分。

对于从 1972 年 11 月 3 日（具体边界在下面讨论）直到另行通知的时间段，一致的国际时间尺度是 UTC（闰秒）。在此段中，Java Time-Scale 与 UTC-SLS 相同。这与没有闰秒的日子的 UTC 相同。在确实有闰秒的日子里，闰秒在一天的最后 1000 秒内平均分布，保持每天正好 86400 秒的外观。

对于 1972 年 11 月 3 日之前的时间段，向后任意延伸，公认的国际时标定义为 UT1，应用前瞻性，相当于本初子午线（格林威治）的（平均）太阳时。在此部分中，Java 时标与公认的国际时标相同。两个段之间的确切边界是 UT1 = UTC 在 1972-11-03T00:00 和 1972-11-04T12:00 之间的时刻。

使用 JSR-310 API 的 Java 时间尺度的实现不需要提供任何亚秒级精度的时钟，或者单调或平滑地进行的时钟。因此，实现不需要实际执行 UTC-SLS 转换或以其他方式了解闰秒。但是，JSR-310 确实要求实现必须记录它们在定义表示当前时刻的时钟时使用的方法。有关可用时钟的详细信息，请参阅 Clock 。

Java 时间标度用于所有日期时间类。这包括 Instant、LocalDate、LocalTime、OffsetDateTime、ZonedDateTime 和 Duration。

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

实现要求：

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

自从：

1.8

参见：

• Serialized Form

字段摘要

字段

修饰符和类型	Field	描述
static final Instant	EPOCH	1970-01-01T00:00:00Z 纪元时刻的常量。
static final Instant	MAX	最大支持 Instant ，'1000000000-12-31T23:59:59.999999999Z'。
static final Instant	MIN	支持的最小值 Instant，'-1000000000-01-01T00:00Z'。

方法总结

修饰符和类型	方法	描述
Temporal	adjustInto(Temporal temporal)	调整指定的时间对象以拥有这个瞬间。
OffsetDateTime	atOffset(ZoneOffset offset)	将这个瞬间与偏移量结合起来创建一个 OffsetDateTime 。
ZonedDateTime	atZone(ZoneId zone)	将这个时刻与时区结合起来创建一个 ZonedDateTime 。
int	compareTo(Instant otherInstant)	将这个瞬间与指定的瞬间进行比较。
boolean	equals(Object other)	检查这个瞬间是否等于指定的瞬间。
static Instant	from(TemporalAccessor temporal)	从时间对象中获取 Instant 的实例。
int	get(TemporalField field)	从此时刻获取指定字段的值作为 int 。
long	getEpochSecond()	从 1970-01-01T00:00:00Z 的 Java 时代获取秒数。
long	getLong(TemporalField field)	从此时刻获取指定字段的值作为 long 。
int	getNano()	获取纳秒数，稍后沿着时间线，从第二个开始。
int	hashCode()	返回此时的哈希码。
boolean	isAfter(Instant otherInstant)	检查此时刻是否在指定时刻之后。
boolean	isBefore(Instant otherInstant)	检查此时刻是否在指定时刻之前。
boolean	isSupported(TemporalField field)	检查是否支持指定的字段。
boolean	isSupported(TemporalUnit unit)	检查是否支持指定的单位。
Instant	minus(long amountToSubtract, TemporalUnit unit)	返回此瞬间的副本，并减去指定的数量。
Instant	minus(TemporalAmount amountToSubtract)	返回此瞬间的副本，并减去指定的数量。
Instant	minusMillis(long millisToSubtract)	返回此瞬间的副本，并减去指定的持续时间（以毫秒为单位）。
Instant	minusNanos(long nanosToSubtract)	返回此瞬间的副本，并减去以纳秒为单位的指定持续时间。
Instant	minusSeconds(long secondsToSubtract)	返回此瞬间的副本，并减去指定的持续时间（以秒为单位）。
static Instant	now()	从系统时钟获取当前时刻。
static Instant	now(Clock clock)	从指定时钟获取当前时刻。
static Instant	ofEpochMilli(long epochMilli)	从 1970-01-01T00:00:00Z 的纪元开始使用毫秒获取 Instant 的实例。
static Instant	ofEpochSecond(long epochSecond)	使用 1970-01-01T00:00:00Z 纪元的秒数获取 Instant 的实例。
static Instant	ofEpochSecond(long epochSecond, long nanoAdjustment)	使用 1970-01-01T00:00:00Z 纪元的秒数和秒的纳秒小数部分获取 Instant 的实例。
static Instant	parse(CharSequence text)	从 2007-12-03T10:15:30.00Z 等文本字符串中获取 Instant 的实例。
Instant	plus(long amountToAdd, TemporalUnit unit)	返回此瞬间的副本，并添加了指定的数量。
Instant	plus(TemporalAmount amountToAdd)	返回此瞬间的副本，并添加了指定的数量。
Instant	plusMillis(long millisToAdd)	返回此瞬间的副本，并添加指定的持续时间（以毫秒为单位）。
Instant	plusNanos(long nanosToAdd)	返回此瞬间的副本，其中添加了以纳秒为单位的指定持续时间。
Instant	plusSeconds(long secondsToAdd)	返回此瞬间的副本，并添加指定的持续时间（以秒为单位）。
<R> R	query(TemporalQuery<R> query)	使用指定的查询立即查询。
ValueRange	range(TemporalField field)	获取指定字段的有效值范围。
long	toEpochMilli()	将此瞬间转换为从 1970-01-01T00:00:00Z 纪元算起的毫秒数。
String	toString()	使用 ISO-8601 表示的这一时刻的字符串表示。
Instant	truncatedTo(TemporalUnit unit)	返回截断为指定单位的此 Instant 的副本。
long	until(Temporal endExclusive, TemporalUnit unit)	根据指定的单位计算到另一个瞬间的时间量。
Instant	with(TemporalAdjuster adjuster)	返回此瞬间的调整副本。
Instant	with(TemporalField field, long newValue)	返回此瞬间的副本，并将指定字段设置为新值。

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

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

字段详细信息

EPOCH

public static final Instant  EPOCH
            

1970-01-01T00:00:00Z 纪元时刻的常量。

MIN

public static final Instant  MIN
            

支持的最小值 Instant，'-1000000000-01-01T00:00Z'。这可以被应用程序用作“很久以前”的瞬间。

这比最小值 LocalDateTime 早一年。这提供了足够的值来处理 ZoneOffset 的范围，它影响除了本地日期时间之外的瞬间。还选择了该值，以使年份的值适合 int 。

MAX

public static final Instant  MAX
            

最大支持 Instant ，'1000000000-12-31T23:59:59.999999999Z'。这可以被应用程序用作“遥远的未来”瞬间。

这比最大值 LocalDateTime 晚了一年。这提供了足够的值来处理 ZoneOffset 的范围，它影响除了本地日期时间之外的瞬间。还选择了该值，以使年份的值适合 int 。

方法详情

now

public static Instant  now()
            

从系统时钟获取当前时刻。

这将查询 system UTC clock 以获取当前时刻。

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

返回：

使用系统时钟的当前时刻，不为空

now

public static Instant  now(Clock  clock)
            

从指定时钟获取当前时刻。

这将查询指定的时钟以获取当前时间。

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

参数：

clock - 使用的时钟，不为空

返回：

当前时刻，不为空

ofEpochSecond

public static Instant  ofEpochSecond(long epochSecond)
            

使用 1970-01-01T00:00:00Z 纪元的秒数获取 Instant 的实例。

纳秒字段设置为零。

参数：

epochSecond - 从 1970-01-01T00:00:00Z 开始的秒数

返回：

瞬间，不为空

抛出：

DateTimeException - 如果瞬间超过最大或最小瞬间

ofEpochSecond

public static Instant  ofEpochSecond(long epochSecond, long nanoAdjustment)
            

使用 1970-01-01T00:00:00Z 纪元的秒数和秒的纳秒小数部分获取 Instant 的实例。

此方法允许传入任意数量的纳秒。工厂将更改秒和纳秒的值，以确保存储的纳秒在 0 到 999,999,999 范围内。例如，以下将产生完全相同的瞬间：

 Instant.ofEpochSecond(3, 1);
 Instant.ofEpochSecond(4, -999_999_999);
 Instant.ofEpochSecond(2, 1000_000_001);
 

参数：

epochSecond - 从 1970-01-01T00:00:00Z 开始的秒数

nanoAdjustment - 对秒数的纳秒调整，正数或负数

返回：

瞬间，不为空

抛出：

DateTimeException - 如果瞬间超过最大或最小瞬间

ArithmeticException - 如果发生数字溢出

ofEpochMilli

public static Instant  ofEpochMilli(long epochMilli)
            

从 1970-01-01T00:00:00Z 的纪元开始使用毫秒获取 Instant 的实例。

秒和纳秒是从指定的毫秒中提取的。

参数：

epochMilli - 从 1970-01-01T00:00:00Z 开始的毫秒数

返回：

瞬间，不为空

抛出：

DateTimeException - 如果瞬间超过最大或最小瞬间

from

public static Instant  from(TemporalAccessor  temporal)
            

从时间对象中获取 Instant 的实例。

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

转换提取 INSTANT_SECONDS 和 NANO_OF_SECOND 字段。

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

参数：

temporal - 要转换的时间对象，不为空

返回：

瞬间，不为空

抛出：

DateTimeException - 如果无法转换为 Instant

parse

public static Instant  parse(CharSequence  text)
            

从 2007-12-03T10:15:30.00Z 等文本字符串中获取 Instant 的实例。

该字符串必须代表 UTC 中的有效时刻，并使用 DateTimeFormatter.ISO_INSTANT 进行解析。

参数：

text - 要解析的文本，不为空

返回：

解析的瞬间，不为空

抛出：

DateTimeParseException - 如果无法解析文本

isSupported

public boolean isSupported(TemporalField  field)
            

检查是否支持指定的字段。

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

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

• NANO_OF_SECOND
• MICRO_OF_SECOND
• MILLI_OF_SECOND
• INSTANT_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
• 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 将根据此日期时间返回有效值，但 INSTANT_SECONDS 除外，它太大而无法放入 int 并抛出 DateTimeException 。所有其他 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 - 如果发生数字溢出

getEpochSecond

public long getEpochSecond()
            

从 1970-01-01T00:00:00Z 的 Java 时代获取秒数。

纪元秒计数是秒的简单递增计数，其中秒 0 是 1970-01-01T00:00:00Z。纳秒部分由 getNano() 返回。

返回：

从 1970-01-01T00:00:00Z 开始的秒数

getNano

public int getNano()
            

获取纳秒数，稍后沿着时间线，从第二个开始。

纳秒级值测量从 getEpochSecond() 返回的秒算起的总纳秒数。

返回：

秒内的纳秒，始终为正，永远不会超过 999,999,999

with

public Instant  with(TemporalAdjuster  adjuster)
            

返回此瞬间的调整副本。

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

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

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

指定者：

with 在接口 Temporal 中

参数：

adjuster - 要使用的调节器，不为空

返回：

基于 this 的 Instant 进行了调整，不为空

抛出：

DateTimeException - 如果无法进行调整

ArithmeticException - 如果发生数字溢出

with

public Instant  with(TemporalField  field, long newValue)
            

返回此瞬间的副本，并将指定字段设置为新值。

这将返回一个 Instant ，基于这个，指定字段的值已更改。如果无法设置该值，因为不支持该字段或出于其他原因，则会抛出异常。

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

• NANO_OF_SECOND - 返回具有指定纳秒的 Instant。纪元秒将保持不变。
• MICRO_OF_SECOND - 返回一个 Instant，其中纳秒替换为指定的微秒乘以 1,000。纪元秒将保持不变。
• MILLI_OF_SECOND - 返回一个 Instant，其中纳秒替换为指定的毫秒乘以 1,000,000。纪元秒将保持不变。
• INSTANT_SECONDS - 返回具有指定纪元秒的 Instant。纳秒将保持不变。

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

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

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

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

指定者：

with 在接口 Temporal 中

参数：

field - 要在结果中设置的字段，不为空

newValue - 结果中字段的新值

返回：

基于 this 的 Instant 具有指定的字段集，不为空

抛出：

DateTimeException - 如果无法设置字段

UnsupportedTemporalTypeException - 如果不支持该字段

ArithmeticException - 如果发生数字溢出

truncatedTo

public Instant  truncatedTo(TemporalUnit  unit)
            

返回截断为指定单位的此 Instant 的副本。

截断即时返回原始副本，其中小于指定单位的字段设置为零。如 toString 中所示，这些字段是根据使用 UTC 偏移量计算的。例如，使用 MINUTES 单位截断将向下舍入到最接近的分钟，将秒和纳秒设置为零。

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

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

参数：

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

返回：

一个 Instant 基于这个瞬间，时间被截断，不为空

抛出：

DateTimeException - 如果单位对于截断无效

UnsupportedTemporalTypeException - 如果不支持该单元

plus

public Instant  plus(TemporalAmount  amountToAdd)
            

返回此瞬间的副本，并添加了指定的数量。

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

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

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

指定者：

plus 在接口 Temporal 中

参数：

amountToAdd - 添加的数量，不为空

返回：

一个基于这个瞬间的 Instant 添加，不为空

抛出：

DateTimeException - 如果无法添加

ArithmeticException - 如果发生数字溢出

plus

public Instant  plus(long amountToAdd, TemporalUnit  unit)
            

返回此瞬间的副本，并添加了指定的数量。

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

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

• NANOS - 返回添加了指定纳秒数的 Instant。这相当于 plusNanos(long) 。
• MICROS - 返回添加了指定微秒数的 Instant。这相当于 plusNanos(long) 的数量乘以 1,000。
• MILLIS - 返回添加了指定毫秒数的 Instant。这相当于 plusNanos(long) 的金额乘以 1,000,000。
• SECONDS - 返回添加了指定秒数的 Instant。这相当于 plusSeconds(long) 。
• MINUTES - 返回添加了指定分钟数的 Instant。这相当于 plusSeconds(long) 的数量乘以 60。
• HOURS - 返回添加了指定小时数的 Instant。这相当于 plusSeconds(long) 的数量乘以 3,600。
• HALF_DAYS - 返回一个 Instant 添加了指定的半天数。这相当于 plusSeconds(long) 的数量乘以 43,200（12 小时）。
• DAYS - 返回添加了指定天数的 Instant。这相当于 plusSeconds(long) 的数量乘以 86,400（24 小时）。

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

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

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

指定者：

plus 在接口 Temporal 中

参数：

amountToAdd - 添加到结果的单位数量，可能为负数

unit - 添加量的单位，不为空

返回：

一个基于这个瞬间的 Instant 添加了指定的数量，不为空

抛出：

DateTimeException - 如果无法添加

UnsupportedTemporalTypeException - 如果不支持该单元

ArithmeticException - 如果发生数字溢出

plusSeconds

public Instant  plusSeconds(long secondsToAdd)
            

返回此瞬间的副本，并添加指定的持续时间（以秒为单位）。

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

参数：

secondsToAdd - 添加的秒数，正数或负数

返回：

一个基于这个瞬间的 Instant 添加了指定的秒数，不为空

抛出：

DateTimeException - 如果结果超过最大或最小瞬间

ArithmeticException - 如果发生数字溢出

plusMillis

public Instant  plusMillis(long millisToAdd)
            

返回此瞬间的副本，并添加指定的持续时间（以毫秒为单位）。

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

参数：

millisToAdd - 要添加的毫秒数，正数或负数

返回：

一个基于这个瞬间的 Instant 添加了指定的毫秒数，不为空

抛出：

DateTimeException - 如果结果超过最大或最小瞬间

ArithmeticException - 如果发生数字溢出

plusNanos

public Instant  plusNanos(long nanosToAdd)
            

返回此瞬间的副本，其中添加了以纳秒为单位的指定持续时间。

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

参数：

nanosToAdd - 添加的纳秒数，正数或负数

返回：

一个基于这个瞬间的 Instant 添加了指定的纳秒，不为空

抛出：

DateTimeException - 如果结果超过最大或最小瞬间

ArithmeticException - 如果发生数字溢出

minus

public Instant  minus(TemporalAmount  amountToSubtract)
            

返回此瞬间的副本，并减去指定的数量。

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

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

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

指定者：

minus 在接口 Temporal 中

参数：

amountToSubtract - 要减去的金额，不为空

返回：

一个基于这个瞬间的 Instant 减法，不为空

抛出：

DateTimeException - 如果无法进行减法

ArithmeticException - 如果发生数字溢出

minus

public Instant  minus(long amountToSubtract, TemporalUnit  unit)
            

返回此瞬间的副本，并减去指定的数量。

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

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

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

指定者：

minus 在接口 Temporal 中

参数：

amountToSubtract - 要从结果中减去的单位数量，可能为负数

unit - 要减去的金额的单位，不为空

返回：

一个基于这个瞬间的 Instant 减去指定的数量，不为空

抛出：

DateTimeException - 如果无法进行减法

UnsupportedTemporalTypeException - 如果不支持该单元

ArithmeticException - 如果发生数字溢出

minusSeconds

public Instant  minusSeconds(long secondsToSubtract)
            

返回此瞬间的副本，并减去指定的持续时间（以秒为单位）。

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

参数：

secondsToSubtract - 减去的秒数，正数或负数

返回：

基于此瞬间的 Instant 减去指定的秒数，不为空

抛出：

DateTimeException - 如果结果超过最大或最小瞬间

ArithmeticException - 如果发生数字溢出

minusMillis

public Instant  minusMillis(long millisToSubtract)
            

返回此瞬间的副本，并减去指定的持续时间（以毫秒为单位）。

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

参数：

millisToSubtract - 要减去的毫秒数，正数或负数

返回：

一个 Instant 基于这个瞬间减去指定的毫秒数，不为空

抛出：

DateTimeException - 如果结果超过最大或最小瞬间

ArithmeticException - 如果发生数字溢出

minusNanos

public Instant  minusNanos(long nanosToSubtract)
            

返回此瞬间的副本，并减去以纳秒为单位的指定持续时间。

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

参数：

nanosToSubtract - 要减去的纳秒，正数或负数

返回：

一个 Instant 基于这个瞬间减去指定的纳秒，不为空

抛出：

DateTimeException - 如果结果超过最大或最小瞬间

ArithmeticException - 如果发生数字溢出

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.INSTANT_SECONDS 和ChronoField.NANO_OF_SECOND 作为字段传递。

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

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

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

指定者：

adjustInto 在接口 TemporalAdjuster 中

参数：

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

返回：

调整后的对象，不为空

抛出：

DateTimeException - 如果无法进行调整

ArithmeticException - 如果发生数字溢出

until

public long until(Temporal  endExclusive, TemporalUnit  unit)
            

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

这根据单个 TemporalUnit 计算两个 Instant 对象之间的时间量。起点和终点是this和指定的时刻。如果结束早于开始，结果将为负。计算返回一个整数，表示两个时刻之间的完整单位数。传递给此方法的 Temporal 使用 from(TemporalAccessor) 转换为 Instant。例如，可以使用 startInstant.until(endInstant, SECONDS) 计算两个日期之间的秒数。

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

  // these two lines are equivalent
  amount = start.until(end, SECONDS);
  amount = SECONDS.between(start, end);
 

应该根据哪个使代码更具可读性来做出选择。

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

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

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

指定者：

until 在接口 Temporal 中

参数：

endExclusive - 结束日期，独占，转换为 Instant ，不为空

unit - 衡量数量的单位，不为空

返回：

这个瞬间和结束瞬间之间的时间量

抛出：

DateTimeException - 如果无法计算金额，或者结束时间无法转换为 Instant

UnsupportedTemporalTypeException - 如果不支持该单元

ArithmeticException - 如果发生数字溢出

atOffset

public OffsetDateTime  atOffset(ZoneOffset  offset)
            

将这个瞬间与偏移量结合起来创建一个 OffsetDateTime 。

这将返回一个 OffsetDateTime 从这一时刻在与 UTC/格林威治的指定偏移处形成的。如果瞬间太大而无法放入偏移日期时间，则会抛出异常。

此方法等效于 OffsetDateTime.ofInstant(this, offset) 。

参数：

offset - 要结合的偏移量，不为空

返回：

从这个瞬间和指定的偏移量形成的偏移日期时间，不为空

抛出：

DateTimeException - 如果结果超出支持的范围

atZone

public ZonedDateTime  atZone(ZoneId  zone)
            

将这个时刻与时区结合起来创建一个 ZonedDateTime 。

这将返回一个 ZonedDateTime 从指定时区的这一时刻形成。如果瞬间太大而无法放入分区日期时间，则会抛出异常。

此方法等效于 ZonedDateTime.ofInstant(this, zone) 。

参数：

zone - 要结合的区域，不为空

返回：

从这个时刻和指定区域形成的分区日期时间，不为空

抛出：

DateTimeException - 如果结果超出支持的范围

toEpochMilli

public long toEpochMilli()
            

将此瞬间转换为从 1970-01-01T00:00:00Z 纪元算起的毫秒数。

如果这个时刻表示时间线上的一个点在未来或过去太远而不适合 long 毫秒，则抛出异常。

如果这个时刻的精度大于毫秒，那么转换将丢弃任何多余的精度信息，就好像以纳秒为单位的量被整数除以一百万。

返回：

自 1970-01-01T00:00:00Z 纪元以来的毫秒数

抛出：

ArithmeticException - 如果发生数字溢出

compareTo

public int compareTo(Instant  otherInstant)
            

将这个瞬间与指定的瞬间进行比较。

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

指定者：

compareTo 在接口 Comparable<Instant> 中

参数：

otherInstant - 另一个要比较的时刻，不为空

返回：

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

抛出：

NullPointerException - 如果 otherInstant 为空

isAfter

public boolean isAfter(Instant  otherInstant)
            

检查此时刻是否在指定时刻之后。

比较基于瞬间的时间线位置。

参数：

otherInstant - 另一个要比较的时刻，不为空

返回：

如果此时刻在指定时刻之后，则为真

抛出：

NullPointerException - 如果 otherInstant 为空

isBefore

public boolean isBefore(Instant  otherInstant)
            

检查此时刻是否在指定时刻之前。

比较基于瞬间的时间线位置。

参数：

otherInstant - 另一个要比较的时刻，不为空

返回：

如果此时刻在指定时刻之前，则为真

抛出：

NullPointerException - 如果 otherInstant 为空

equals

public boolean equals(Object  other)
            

检查这个瞬间是否等于指定的瞬间。

比较基于瞬间的时间线位置。

重写：

equals 在类 Object 中

参数：

other - 另一个瞬间，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()
            

使用 ISO-8601 表示的这一时刻的字符串表示。

使用的格式与 DateTimeFormatter.ISO_INSTANT 相同。

重写：

toString 在类 Object 中

返回：

这一瞬间的 ISO-8601 表示，不为空