Instant (Java Platform SE 8 )

java.lang.Object
- java.time.Instant

All Implemented Interfaces:

Serializable ， Comparable < Instant >， Temporal ， TemporalAccessor ， TemporalAdjuster
```
public final class Instant
extends Object
implements Temporal, TemporalAdjuster, Comparable<Instant>, Serializable
```
在时间线上的瞬间点。
该类在时间线上建立单个瞬时点。这可能用于在应用程序中记录事件时间戳。

实际上，这一瞬间存在一些限制。可测量的时间线限制在long中可以持有的long 。这大于当前估计的宇宙年龄。该瞬间存储为纳秒分辨率。

瞬间的范围需要存储大于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 and Description
`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	Method and Description
`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)` 获得的一个实例 `Instant`从1970-01-01T00划时代使用毫秒：00：00Z。
`static Instant`	`ofEpochSecond(long epochSecond)` 使用从1970-01-01T00：00：00Z的时代开始的秒数获得一个 `Instant`的实例。
`static Instant`	`ofEpochSecond(long epochSecond, long nanoAdjustment)` 使用从1970-01-01T00：00：00Z的时期开始的秒数获得 `Instant`的实例， `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 。这提供了足够的值来处理的范围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)
```
    获得的一个实例Instant从1970-01-01T00划时代使用毫秒：00：00Z。
    从指定的毫秒中提取秒和纳秒。
    
    参数
    
    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 - 要解析的文本，不为null
    
    结果
    
    解析的瞬间，不为空
    
    异常
    
    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的秒的简单递增计数。当天的纳秒部分由getNanosOfSecond返回。
    
    结果
    
    从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的Instant。第二纪将不变。
    - MICRO_OF_SECOND - 返回一个Instant ，其纳秒用指定的微秒乘以1000替换。第二纪将不变。
    - MILLI_OF_SECOND - 返回一个Instant ，纳秒将以指定的毫秒数乘以1,000,000。第二纪将不变。
    - INSTANT_SECONDS - 返回一个Instant与指定的时代 - 秒。纳秒将不变。
    在所有情况下，如果新值超出该字段值的有效范围，那么DateTimeException将被抛出。
    
    所有其他ChronoField实例将抛出一个UnsupportedTemporalTypeException 。
    
    如果该字段不是ChronoField ，则通过调用TemporalField.adjustInto(Temporal, long) this作为参数的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 - 要截断的单位，不为空
    
    结果
    
    一个 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 ，其中添加了Instant的纳秒数。这相当于plusNanos(long) 。
    - MICROS - 返回一个Instant了指定微秒数的Instant。这相当于plusNanos(long) ，数量乘以1,000。
    - MILLIS -返回Instant添加了指定的毫秒数。相当于plusNanos(long) ，数额乘以1,000,000。
    - SECONDS - 返回一个Instant ，加上指定的秒数。这相当于plusSeconds(long) 。
    - MINUTES - 返回具有Instant分钟数的Instant。这相当于plusSeconds(long) ，数量乘以60。
    - HOURS -返回Instant与加入小时指定数目。相当于plusSeconds(long) ，金额乘以3,600。
    - 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 - 要添加的单位，不为空
    
    结果
    
    一个 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 - 增加的纳秒，正或负
    
    结果
    
    一个 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对象定义了用于获取结果的逻辑。阅读查询的文档，以了解该方法的结果。
    
    该方法的结果是通过调用指定的查询this作为参数的TemporalQuery.queryFrom(TemporalAccessor)方法获得的。
    
    Specified by:
    
    query在界面 TemporalAccessor
    
    参数类型
    
    R - 结果的类型
    
    参数
    
    query - 要调用的查询，不为null
    
    结果
    
    查询结果可能返回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)两个日期之间的天数。
    
    使用这种方法有两种等效的方法。第一个是调用这个方法。二是使用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 。
    这将返回一个OffsetDateTime在指定的从UTC /格林威治偏移从该时刻形成。如果瞬间太大而无法适应偏移日期时间，将抛出异常。
    
    此方法相当于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为null
  - 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