All Implemented Interfaces:

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之间。时标是从标准的Java时代1970-01-01T00:00:00Z测量的，其中时期之后的时刻具有正值，较早的时刻具有负值。对于时代第二和纳秒部分，时间线上的值越大越小。

时间尺度

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

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

不幸的是，随着地球的旋转，一天的长短变化。此外，随着时间的推移，一天的平均长度随着地球的减速而变得越来越长。因此，2012年太阳日的长度稍长于86400 SI秒。任何一天的实际长度以及地球减速的数量都是不可预知的，只能通过测量来确定。 UT1时间尺度捕获一天中的准确时间，但在一天之后的一段时间内才可用。

UTC时间刻度是将UT1的所有额外分数从UT1捆绑到整秒钟的标准方法，称为闰秒。根据地球的旋转变化，可以添加或删除闰秒。因此，为了保持日子与太阳对齐，UTC允许一天有86399 SI秒或86401 SI秒。

现代UTC时间尺度于1972年引入，引入了整个飞跃的概念。在1958年和1972年之间，UTC的定义是复杂的，次要的次秒级和对名义第二的长度的改变。截至2012年，正在进行讨论，以再次更改UTC的定义，有可能删除闰秒或引入其他更改。

鉴于上述精确计时的复杂性，该Java API定义了自己的时间尺度Java时间尺度 。

Java时间刻度将每个日历日划分为86400个细分，称为秒。这些秒可能与SI秒不同。它与事实上的国际民事时间尺度非常吻合，不时定义哪些变化。

Java时间尺度对时间线的不同部分的定义略有不同，每个时间尺度基于用作民事时间基础的一致性国际时间尺度。每当修改或替换国际商定的时间尺度时，必须为其定义新的Java Time-Scale部分。每个细分必须符合以下要求：
- Java时间尺度应与国际民用时间尺度相匹配;
- Java时间尺度应每天中午完全符合国际民用时间尺度;
- Java时间尺度应与国际民用时间尺度有明确的关系。
目前，截至2013年，Java时间尺度中有两个部分。
对于从1972-11-03（截面如下所述的准确边界）的细分，直到另行通知，国际时间尺度是UTC（具有闰秒）。在此段中，Java时间刻度与UTC-SLS相同。这与UTC没有闰秒的天数相同。在有闰秒的日子里，闰秒在一天的最后1000秒内平均分布，保持每天86400秒的出现。

对于1972-11-03之前的部分，任意延伸回来，国际统一时间尺度被定义为UT1，应用于光学上，这相当于主要子午线（格林威治）的（平均）太阳时间。在这一部分，Java时间尺度与国际时间标准一致。两段之间的确切边界是1972-11-03T00：00和1972-11-04T12：00之间的UT1 = UTC的时刻。

使用JSR-310 API的Java时间尺度的实现不需要提供任何次秒级准确的或者单调或平滑地进行的时钟。因此实际上不需要实际执行UTC-SLS转换，否则不需要知道闰秒。然而，JSR-310确实要求在定义表示当前时刻的时钟时，实现必须记录它们使用的方法。有关可用时钟的详细信息，请参阅Clock 。

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

这是一个value-based课; 在Instant实例上使用身份敏感操作（包括引用等式（ == ），身份哈希码或同步）可能会产生不可预测的结果，应该避免。 equals方法应用于比较。
实现要求：

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

从以下版本开始：

1.8

另请参见：

Serialized Form

Field Summary

Fields
Modifier and Type	Field	描述
`static Instant`	`EPOCH`	常数为1970-01-01T00：00：00Z时代瞬间。
`static Instant`	`MAX`	最大支持 `Instant` ，'1000000000-12-31T23：59：59.999999999Z'。
`static Instant`	`MIN`	最低支持 `Instant` ，'-1000000000-01-01T00：00Z'。

方法摘要

所有方法静态方法接口方法具体的方法
Modifier and Type	方法	描述
`Temporal`	`adjustInto(Temporal temporal)`	调整指定的时间对象具有这个瞬间。
`OffsetDateTime`	`atOffset(ZoneOffset offset)`	将此瞬间与偏移组合，创建一个 `OffsetDateTime` 。
`ZonedDateTime`	`atZone(ZoneId zone)`	将此瞬间与时区相结合，创建一个 `ZonedDateTime` 。
`int`	`compareTo(Instant otherInstant)`	将此瞬间与指定的时刻进行比较。
`boolean`	`equals(Object otherInstant)`	检查这个瞬间是否等于指定的时刻。
`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)`	将指定的字段设置为新值返回此瞬间的副本。

Methods inherited from class 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晚了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的实例， 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的实例。
    这将根据指定的时间获得一个瞬间。 A TemporalAccessor表示日期和时间信息的任意集合，该工厂将转换为Instant的实例。
    
    该转换提取了INSTANT_SECONDS和NANO_OF_SECOND字段。
    
    该方法匹配功能界面TemporalQuery的签名，允许它通过方法参考Instant::from用作查询。
    
    参数
    
    temporal - 要转换的时间对象，不为null
    
    结果
    
    即时，不为空
    
    异常
    
    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)
```
    检查指定的字段是否受支持。
    这将检查是否可以查询指定字段的此即时。如果是假，然后调用range ， get和with(TemporalField, long)方法会抛出异常。
    
    如果该字段是一个ChronoField，那么查询是在这里实现的。支持的字段有：
    
    NANO_OF_SECOND
    
    MICRO_OF_SECOND
    
    MILLI_OF_SECOND
    
    INSTANT_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
    
    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将根据此日期时间返回有效值，但INSTANT_SECONDS用于int并抛出DateTimeException 。所有其他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 - 如果发生数字溢出
  - 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作为参数。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    with在接口 Temporal
    
    参数
    
    adjuster - 调整器使用，不为空
    
    结果
    
    一个 Instant基于 this进行了调整，不为null
    
    异常
    
    DateTimeException - 如果不能进行调整
    
    ArithmeticException - 如果发生数字溢出
  - with
```
public Instant with(TemporalField field,
                    long newValue)
```
    将指定的字段设置为新值返回此瞬间的副本。
    这将返回一个Instant ，基于此，更改指定字段的值。如果不可能设置该值，因为该字段不受支持或出于某种其他原因，则抛出异常。
    
    如果该字段是ChronoField，则在此处执行调整。支持的字段的行为如下：
    
    NANO_OF_SECOND - 返回一个Instant具有指定的纳秒。第二纪将不变。
    
    MICRO_OF_SECOND - 返回一个Instant ， Instant秒替换为指定的微秒乘以1,000。第二纪将不变。
    
    MILLI_OF_SECOND - 返回Instant ，以秒为单位，以秒为单位替换为指定的毫秒数乘以1,000,000。第二纪将不变。
    
    INSTANT_SECONDS - 返回具有指定时代的Instant 。纳秒将不变。
    
    在所有情况下，如果新值超出该字段值的有效范围，那么将抛出一个DateTimeException 。
    
    所有其他ChronoField实例将抛出一个UnsupportedTemporalTypeException 。
    
    如果该字段是不是一个ChronoField ，则此方法的结果是通过调用得到TemporalField.adjustInto(Temporal, long)传递this作为参数。在这种情况下，该字段决定是否以及如何调整即时。
    
    此实例是不可变的，不受此方法调用的影响。
    Specified by:
    
    with在接口 Temporal
    
    参数
    
    field - 要在结果中设置的字段，不为null
    
    newValue - 结果中字段的新值
    
    结果
    
    一个 Instant基于 this指定的字段设置，不为null
    
    异常
    
    DateTimeException - 如果字段无法设置
    
    UnsupportedTemporalTypeException - 如果不支持该字段
    
    ArithmeticException - 如果发生数字溢出
  - truncatedTo
```
public Instant truncatedTo(TemporalUnit unit)
```
    将此Instant的副本截回到指定的单位。
    截断该瞬间返回原始数据的副本，该字段小于设置为零的指定单位。这些字段是基于使用UTC偏移量计算的，如toString 。例如，使用MINUTES单位截断将舍入到最近的分钟，将秒和纳秒设置为零。
    
    该单位必须有一个duration ，划分为标准日期的长度，无余数。这包括所有提供的时间单位在ChronoUnit和DAYS 。其他单位抛出异常。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    unit - 截断到的单位，不为null
    
    结果
    
    一个 Instant基于这个瞬间截断时间，不为null
    
    异常
    
    DateTimeException - 如果单位无效截断
    
    UnsupportedTemporalTypeException - 如果不支持本机
  - plus
```
public Instant plus(TemporalAmount amountToAdd)
```
    返回添加指定数量的此瞬间的副本。
    这将返回一个Instant ，基于此，添加了指定的数量。金额通常为Duration，但可能是实现TemporalAmount接口的任何其他类型。
    
    通过调用TemporalAmount.addTo(Temporal)将计算委托给金额对象。金额实施可以以任何愿望的方式实现添加，但通常可以回调到plus(long, TemporalUnit) 。请参阅金额执行的文档，以确定是否可以成功添加。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    plus在接口 Temporal
    
    参数
    
    amountToAdd - 要添加的金额，不为null
    
    结果
    
    一个 Instant基于这个瞬间与添加，而不是null
    
    异常
    
    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) ，金额乘以3600。
    
    HALF_DAYS - 返回一个Instant ，加上指定的半天。相当于plusSeconds(long) ，金额乘以43.00 （12小时）。
    
    DAYS - 返回指定加入天数的Instant 。这相当于plusSeconds(long) ，数额乘以86,400（24小时）。
    
    所有其他ChronoUnit实例将抛出一个UnsupportedTemporalTypeException 。
    
    如果该字段是不是一个ChronoUnit ，则此方法的结果是通过调用得到TemporalUnit.addTo(Temporal, long)传递this作为参数。在这种情况下，单元确定是否以及如何执行添加。
    
    此实例是不可变的，不受此方法调用的影响。
    Specified by:
    
    plus在接口 Temporal
    
    参数
    
    amountToAdd - 添加到结果中的单位数量可能为负数
    
    unit - 要添加的单位，不为null
    
    结果
    
    一个 Instant基于这个瞬间与指定的量添加，不为null
    
    异常
    
    DateTimeException - 如果不能添加
    
    UnsupportedTemporalTypeException - 如果不支持本机
    
    ArithmeticException - 如果发生数字溢出
  - plusSeconds
```
public Instant plusSeconds(long secondsToAdd)
```
    以指定的持续时间返回此瞬间的副本，以秒为单位。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    secondsToAdd - 要添加的秒数，正数或负数
    
    结果
    
    一个 Instant基于这个瞬间添加了指定的秒，不为null
    
    异常
    
    DateTimeException - 如果结果超过最大或最小时刻
    
    ArithmeticException - 如果发生数字溢出
  - plusMillis
```
public Instant plusMillis(long millisToAdd)
```
    以毫秒为单位的指定持续时间返回此瞬间的副本。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    millisToAdd - 要添加的毫秒数，正数或负数
    
    结果
    
    一个 Instant基于这个瞬间添加了指定的毫秒，不为null
    
    异常
    
    DateTimeException - 如果结果超过最大或最小时间
    
    ArithmeticException - 如果发生数字溢出
  - plusNanos
```
public Instant plusNanos(long nanosToAdd)
```
    以指定的持续时间返回此瞬间的副本，以纳秒为单位。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    nanosToAdd - nanosToAdd秒，正或负
    
    结果
    
    一个 Instant基于这个瞬间添加了指定的纳秒，不为null
    
    异常
    
    DateTimeException - 如果结果超过最大或最小速度
    
    ArithmeticException - 如果发生数字溢出
  - minus
```
public Instant minus(TemporalAmount amountToSubtract)
```
    返回此时刻的副本，减去指定的金额。
    这将返回一个Instant ，基于此，减去指定的数量。金额通常为Duration，但可能是实现TemporalAmount界面的任何其他类型。
    
    通过调用TemporalAmount.subtractFrom(Temporal)将计算委托给金额对象。数量执行可以以任何希望的方式实现减法，但通常可以回调到minus(long, TemporalUnit) 。请参阅数量执行的文档，以确定是否可以成功减去它们。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    minus在接口 Temporal
    
    参数
    
    amountToSubtract - 减去量，不为空
    
    结果
    
    一个 Instant基于这个瞬间与减法而不是null
    
    异常
    
    DateTimeException - 如果不能进行减法
    
    ArithmeticException - 如果发生数字溢出
  - minus
```
public Instant minus(long amountToSubtract,
                     TemporalUnit unit)
```
    返回此时刻的副本，减去指定的金额。
    这将返回一个Instant ，基于这一个，减去的单位数量。如果不可能减去金额，因为该单位不受支持或出于某种其他原因，则会抛出异常。
    
    这个方法相当于plus(long, TemporalUnit) ，这个数量是否定的。请参阅该方法，以了解如何添加，从而减去运算。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    minus在接口 Temporal
    
    参数
    
    amountToSubtract - 从结果中减去的单位数量可能为负数
    
    unit - 减去量的单位，不为空
    
    结果
    
    一个 Instant基于此瞬间指定的数量减去，不为null
    
    异常
    
    DateTimeException - 如果不能进行减法
    
    UnsupportedTemporalTypeException - 如果不支持本机
    
    ArithmeticException - 如果发生数字溢出
  - minusSeconds
```
public Instant minusSeconds(long secondsToSubtract)
```
    以秒为单位返回指定持续时间的此瞬间的副本。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    secondsToSubtract - 减去正数或负数的秒数
    
    结果
    
    一个 Instant基于此瞬间减去指定的秒数，不为空
    
    异常
    
    DateTimeException - 如果结果超过最大或最小瞬间
    
    ArithmeticException - 如果发生数字溢出
  - minusMillis
```
public Instant minusMillis(long millisToSubtract)
```
    以毫秒为单位的指定持续时间返回此瞬间的副本。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    millisToSubtract - 减去正数或负数的毫秒数
    
    结果
    
    一个 Instant基于此瞬间减去指定的毫秒，不为null
    
    异常
    
    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作为参数。
    
    Specified by:
    
    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);
    
    此实例是不可变的，不受此方法调用的影响。
    Specified by:
    
    adjustInto在接口 TemporalAdjuster
    
    参数
    
    temporal - 要调整的目标对象，不为null
    
    结果
    
    调整对象，不为null
    
    异常
    
    DateTimeException - 如果不能进行调整
    
    ArithmeticException - 如果发生数字溢出
  - until
```
public long until(Temporal endExclusive,
                  TemporalUnit unit)
```
    根据指定单位计算直到另一瞬间的时间量。
    这可以计算一个Instant对象之间的时间量，单个TemporalUnit 。起点和终点是this和指定的时刻。如果结束在开始之前，结果将为负数。计算返回一个整数，表示两个时刻之间完整单位的数量。所述Temporal传递给此方法被转换为Instant使用from(TemporalAccessor) 。例如，可以使用startInstant.until(endInstant, SECONDS)计算两个日期之间的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作为第一个参数和转换后的输入时间作为第二个参数。
    
    此实例是不可变的，不受此方法调用的影响。
    Specified by:
    
    until在接口 Temporal
    
    参数
    
    endExclusive - 结束日期，排他，转换为 Instant ，不为空
    
    unit - 衡量金额的单位，不为空
    
    结果
    
    这个瞬间和结束时刻之间的时间量
    
    异常
    
    DateTimeException - 如果不能计算金额，或者结束时间不能转换为 Instant
    
    UnsupportedTemporalTypeException - 如果不支持本机
    
    ArithmeticException - 如果发生数字溢出
  - atOffset
```
public OffsetDateTime atOffset(ZoneOffset offset)
```
    将此瞬间与偏移量组合起来创建一个OffsetDateTime 。
    这将从UTC /格林威治指定的偏移量从此时刻返回OffsetDateTime 。如果瞬间太大而无法适应偏移日期时间，将抛出异常。
    
    这个方法相当于OffsetDateTime.ofInstant(this, offset) 。
    
    参数
    
    offset - 要组合的偏移量，不为空
    
    结果
    
    从该时刻形成的偏移日期时间和指定的偏移量，不为空
    
    异常
    
    DateTimeException - 如果结果超出了支持的范围
  - atZone
```
public ZonedDateTime atZone(ZoneId zone)
```
    将此瞬间与时区相结合，创建一个ZonedDateTime 。
    这将返回一个ZonedDateTime ，从这个时刻在指定的时区形成。如果瞬间太大，无法进入划定的日期时间，将会抛出异常。
    
    此方法相当于ZonedDateTime.ofInstant(this, zone) 。
    
    参数
    
    zone - 要组合的区域，不为空
    
    结果
    
    从这个时刻和指定的区域形成的划分的日期时间，不为null
    
    异常
    
    DateTimeException - 如果结果超出支持范围
  - toEpochMilli
```
public long toEpochMilli()
```
    将此瞬间转换为1970-01-01T00：00：00Z的时期的毫秒数。
    如果这个时刻在时间线上表示一个太远的距离或过去，以适应long毫秒，那么抛出异常。
    
    如果这个瞬间具有大于毫秒的精度，则转换将丢弃任何超量精度信息，就好像以毫秒为单位的整数除以一百万。
    
    结果
    
    自1970-01-01T00：00：00Z以来的毫秒数
    
    异常
    
    ArithmeticException - 如果发生数字溢出
  - compareTo
```
public int compareTo(Instant otherInstant)
```
    将此瞬间与指定的时刻进行比较。
    比较是基于时刻的时间位置。它与“等于”一致，如Comparable所定义。
    
    Specified by:
    
    compareTo在接口 Comparable<Instant>
    
    参数
    
    otherInstant - 另一个即时比较，不为null
    
    结果
    
    比较器值为负，如果较小，则如果较大则为正
    
    异常
    
    NullPointerException - 如果otherInstant为空
  - isAfter
```
public boolean isAfter(Instant otherInstant)
```
    检查这个瞬间是否在指定的时刻之后。
    比较是基于时刻的时间位置。
    
    参数
    
    otherInstant - 另一个即时比较，不为null
    
    结果
    
    如果这个瞬间是在指定的时刻之后，则为真
    
    异常
    
    NullPointerException - 如果otherInstant为空
  - isBefore
```
public boolean isBefore(Instant otherInstant)
```
    检查这个时刻是否在指定的时刻之前。
    比较是基于时刻的时间位置。
    
    参数
    
    otherInstant - 另一个即时比较，不为null
    
    结果
    
    如果这个时刻在指定的时刻之前，则为true
    
    异常
    
    NullPointerException - 如果otherInstant为空
  - equals
```
public boolean equals(Object otherInstant)
```
    检查这个瞬间是否等于指定的时刻。
    比较是基于时刻的时间位置。
    
    重写：
    
    equals在 Object
    
    参数
    
    otherInstant - 另一个即时，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表示，不为空

Class Instant

时间尺度

Field Summary

方法摘要

Methods inherited from class java.lang.Object

字段详细信息

EPOCH

MIN

MAX

方法详细信息

now

now

ofEpochSecond

ofEpochSecond

ofEpochMilli

from

parse

isSupported

isSupported

range

get

getLong

getEpochSecond

getNano

with

with

truncatedTo

plus

plus

plusSeconds

plusMillis

plusNanos

minus

minus

minusSeconds

minusMillis

minusNanos

query

adjustInto

until

atOffset

atZone

toEpochMilli

compareTo

isAfter

isBefore

equals

hashCode

toString