实现的所有接口

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测量的，其中时期之后的时刻具有正值，而早期时刻具有负值。对于时期秒和纳秒部分，较大的值总是在时间线上晚于比较小的值。

时间尺度

太阳日的长度是人类测量时间的标准方式。传统上将其细分为24小时60分钟60秒，形成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 Time-Scale 。

Java Time-Scale将每个日历日划分为86400个细分，称为秒。这些秒可能与SI秒不同。它与事实上的国际民事时间表紧密匹配，其定义随时变化。

Java时间尺度对时间线的不同部分的定义略有不同，每个部分都基于用作民用时间基础的共识国际时间尺度。每当修改或替换国际商定的时间尺度时，必须为其定义Java时间尺度的新部分。每个细分必须满足以下要求：
- Java时标应与基础国际民用时标紧密匹配;
- Java时标应与每天中午的国际民用时标完全匹配;
- Java时标应与国际民用时标具有精确定义的关系。
目前，截至2013年，Java时间尺度中有两个部分。
对于从1972-11-03（下面讨论的确切边界）直到另行通知的段，共识国际时间尺度是UTC（具有闰秒）。在此段中，Java Time-Scale与UTC-SLS相同。这与没有闰秒的天数相同。在具有闰秒的日子里，闰秒在一天的最后1000秒内平均分布，保持每天正好86400秒的外观。

对于1972-11-03之前的区段，任意向后延伸，共识国际时间尺度被定义为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班; 在Instant实例上使用身份敏感操作（包括引用相等（ == ），标识哈希码或同步）可能会产生不可预测的结果，应该避免使用。 equals方法应该用于比较。
实现要求：

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

从以下版本开始：

1.8

另请参见：

Serialized Form

字段汇总

字段
变量和类型	字段	描述
`static Instant`	`EPOCH`	1970-01-01T00：00：00Z时刻的常数。
`static Instant`	`MAX`	支持的最大值为 `Instant` ，'1000000000-12-31T23：59：59.999999999Z'。
`static Instant`	`MIN`	支持的最小值为 `Instant` ，' - 100000000000-01-01T00：00Z'。

方法摘要

所有方法静态方法实例方法具体的方法
变量和类型	方法	描述
`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)`	返回此瞬间的副本，并将指定的字段设置为新值。

声明方法的类 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 ，' - 100000000000-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 - 要转换的临时对象，而不是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
    
    参数
    
    字段 - 要检查的字段，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 in interface Temporal
    
    参数
    
    unit - 要检查的单位，null返回false
    
    结果
    
    如果可以添加/减去单位，则为true，否则为false
  - range
```
public ValueRange range(TemporalField field)
```
    获取指定字段的有效值范围。
    范围对象表示字段的最小和最大有效值。此瞬间用于提高返回范围的准确性。如果无法返回范围，因为不支持该字段或由于某些其他原因，将引发异常。
    
    如果该字段是ChronoField，则在此处实现查询。 supported fields将返回适当的范围实例。所有其他ChronoField实例将抛出UnsupportedTemporalTypeException 。
    
    如果该字段不是ChronoField ，则通过调用this作为参数调用TemporalField.rangeRefinedBy(TemporalAccessor)获得此方法的结果。是否可以获得范围由该字段确定。
    
    Specified by:
    
    range在界面 TemporalAccessor
    
    参数
    
    字段 - 要查询范围的字段，而不是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
    
    参数
    
    字段 - 要获取的字段，而不是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
    
    参数
    
    字段 - 要获取的字段，而不是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 - 要使用的调整器，不为null
    
    结果
    
    Instant基于 this进行了调整，而不是null
    
    异常
    
    DateTimeException - 如果无法进行调整
    
    ArithmeticException - 如果发生数字溢出
  - with
```
public Instant with(TemporalField field,
                    long newValue)
```
    返回此瞬间的副本，并将指定的字段设置为新值。
    这将返回Instant （基于此值），并更改指定字段的值。如果无法设置该值，因为不支持该字段或由于某些其他原因，将引发异常。
    
    如果该字段是ChronoField，则在此处执行调整。支持的字段表现如下：
    
    NANO_OF_SECOND - 返回具有指定的Instant级的Instant 。第二纪元将保持不变。
    
    MICRO_OF_SECOND - 返回Instant ，其中纳秒数由指定的微秒乘以1,000替换。第二纪元将保持不变。
    
    MILLI_OF_SECOND - 返回Instant ，其中纳秒数由指定的毫秒乘以1,000,000替换。第二纪元将保持不变。
    
    INSTANT_SECONDS - 返回具有指定纪元秒的Instant 。纳秒将保持不变。
    
    在所有情况下，如果新值超出该字段的有效值范围，则将抛出DateTimeException 。
    
    所有其他ChronoField实例将抛出UnsupportedTemporalTypeException 。
    
    如果该字段不是ChronoField ，则通过调用this作为参数调用TemporalField.adjustInto(Temporal, long)获得此方法的结果。在这种情况下，该字段确定是否以及如何调整瞬间。
    
    此实例是不可变的，不受此方法调用的影响。
    Specified by:
    
    with在界面 Temporal
    
    参数
    
    字段 - 要在结果中设置的字段，不为null
    
    newValue - 结果中字段的新值
    
    结果
    
    Instant基于 this并指定了字段集，不为空
    
    异常
    
    DateTimeException - 如果无法设置该字段
    
    UnsupportedTemporalTypeException - 如果不支持该字段
    
    ArithmeticException - 如果发生数字溢出
  - truncatedTo
```
public Instant truncatedTo(TemporalUnit unit)
```
    返回截断到指定单位的此Instant的副本。
    截断瞬间会返回原始副本，其中小于指定单位的字段设置为零。这些字段是根据使用UTC偏移计算的，如toString 。例如，使用MINUTES单位截断将向下舍入到最接近的分钟，将秒和纳秒设置为零。
    
    该单位必须有一个duration ，分为标准日的长度，没有余数。这包括ChronoUnit和DAYS上提供的所有时间单位。其他单位抛出异常。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    unit - 要截断的单位，而不是null
    
    结果
    
    基于此瞬间的 Instant ，时间被截断，不为空
    
    异常
    
    DateTimeException - 如果单位对于截断无效
    
    UnsupportedTemporalTypeException - 如果不支持该装置
  - plus
```
public Instant plus(TemporalAmount amountToAdd)
```
    返回此瞬间的副本，并添加指定的数量。
    这将返回一个Instant ，基于此，添加了指定的数量。金额通常为Duration，但可以是实现TemporalAmount接口的任何其他类型。
    
    通过调用TemporalAmount.addTo(Temporal)将计算委托给amount对象。实施金额可以任意方式自由实施，但通常会回拨plus(long, TemporalUnit) 。请参阅金额实施的文档，以确定是否可以成功添加。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    plus in interface 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,400 （12小时）。
    
    DAYS - 返回一个指定天数的Instant 。这相当于plusSeconds(long) ，金额乘以86,400（24小时）。
    
    所有其他ChronoUnit实例将抛出UnsupportedTemporalTypeException 。
    
    如果该字段不是ChronoUnit ，则通过调用this作为参数调用TemporalUnit.addTo(Temporal, long)获得此方法的结果。在这种情况下，该单元确定是否以及如何执行添加。
    
    此实例是不可变的，不受此方法调用的影响。
    Specified by:
    
    plus在界面 Temporal
    
    参数
    
    amountToAdd - 要添加到结果中的单位数量可能为负数
    
    unit - 要添加的金额的单位，而不是空
    
    结果
    
    基于此瞬间的 Instant ，添加了指定的金额，而不是空
    
    异常
    
    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)将计算委托给amount对象。实现量可以任意方式自由实现减法，但通常会回拨到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 ，减去指定的数量，不为空
    
    异常
    
    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作为参数。
    
    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
    
    结果
    
    调整后的对象，不为空
    
    异常
    
    DateTimeException - 如果无法进行调整
    
    ArithmeticException - 如果发生数字溢出
  - until
```
public long until(Temporal endExclusive,
                  TemporalUnit unit)
```
    根据指定的单位计算到另一个瞬间的时间量。
    这将根据单个TemporalUnit计算两个Instant对象之间的时间量。起点和终点是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 / Greenwich的指定偏移处形成的OffsetDateTime 。如果瞬间太大而无法适应偏移日期时间，则会抛出异常。
    
    此方法相当于OffsetDateTime.ofInstant(this, offset) 。
    
    参数
    
    offset - 要与之结合的偏移量，而不是null
    
    结果
    
    从此瞬间和指定的偏移量形成的偏移日期时间，不为空
    
    异常
    
    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为null
  - isAfter
```
public boolean isAfter(Instant otherInstant)
```
    检查此瞬间是否在指定的瞬间之后。
    比较基于时刻的时间线位置。
    
    参数
    
    otherInstant - 要比较的另一个瞬间，而不是null
    
    结果
    
    如果此瞬间在指定的瞬间之后，则为true
    
    异常
    
    NullPointerException - 如果otherInstant为null
  - isBefore
```
public boolean isBefore(Instant otherInstant)
```
    检查此瞬间是否在指定的瞬间之前。
    比较基于时刻的时间线位置。
    
    参数
    
    otherInstant - 要比较的另一个瞬间，而不是null
    
    结果
    
    如果此时刻在指定时刻之前，则为true
    
    异常
    
    NullPointerException - 如果otherInstant为null
  - equals
```
public boolean equals(Object otherInstant)
```
    检查此瞬间是否等于指定的瞬间。
    比较基于时刻的时间线位置。
    
    重写：
    
    equals在课程 Object
    
    参数
    
    otherInstant - 另一个瞬间，null返回false
    
    结果
    
    如果另一个瞬间等于这个瞬间，则为true
    
    另请参见：
    
    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

时间尺度

字段汇总

方法摘要

声明方法的类 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