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代表时代秒和纳秒int代表秒，这将永远是0和999999999之间。时代秒测量从哪里瞬间1970-01-01T00:00:00Z标准java时代之后的时代有正面的价值观，和更早的时刻有负面价值。对于这两个时代的第二和纳秒级的部分，一个更大的值总是在后面的时间线比一个较小的值。

时间尺度

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

现代计时是基于原子钟精确地定义一个硅二相对于铯原子的跃迁。被定义为一个硅第二的长度是非常接近的一天的第八万六千四百个部分。

不幸的是，由于地球旋转的长度变化的一天。此外，随着时间的推移，地球的平均长度也越来越长，随着时间的推移，的平均长度也越来越长了。其结果是，在2012日的太阳日的长度略长于86400秒的时间。任何给定的一天的实际长度和地球正在放缓的金额是不可预测的，只能通过测量确定。UT1的时间尺度捕获一天的准确长度，但只有一天之后完成了一些时间。

UTC时间尺度是把所有的第二附加组分为全秒UT1的标准方法，称为闰秒。一个跳跃的第二个可能被添加或删除，这取决于地球的旋转变化。因此，UTC允许一天有86399秒或86401秒，硅Si必要为了保持每天与太阳对齐。

现代的UTC时间尺度在1972被介绍，介绍整个闰秒的概念。1958和1972之间，UTC的定义是复杂的，小的子二飞跃和改变的概念第二长度。截至2012日，目前正在讨论再次改变UTC的定义，有可能删除闰秒或介绍其他的变化。

给出了精确的计时上面描述的复杂性，这个java API定义了它自己的时间尺度，java的时间尺度。

java的时间尺度划分每个日历天为86400区，称为秒。这些秒可能不同于第二秒。它紧密地与事实上的国际民事时间尺度相匹配，它的定义是不时变化的。

java的时间尺度为时间线的不同段的定义略有不同，每个基于共识的国际尺度，作为民用时间的基础上。每当国际商定的时间尺度修改或替换，对java的时间尺度的一个新的细分市场必须为它定义。每一部分必须满足这些要求：
- java的时间尺度应密切配合相关国际民用时间尺度；
- java的时间尺度应完全符合国际民用时间每天中午；
- java的时间尺度上应当有一个精确的定义关系到国际民用时间尺度。
目前，截至2013日，在java的时间尺度两段。
这段1972-11-03（精确边界下面讨论）直到进一步通知，国际共识的时间尺度是UTC（闰秒）。在这段时间的java的规模是相同的UTC-SLS。这是UTC的日子，没有一个闰秒相同。在有一个飞跃的日子里，第二个飞跃是在过去的1000秒同样的传播，保持每天86400秒的外观。

之前1972-11-03为段，向后延伸的任意远，共识的国际尺度定义为UT1，应用proleptically，这相当于太阳的时间（平均）的本初子午线（格林尼治）。在这段时间的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法进行比较。
实现要求：

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

从以下版本开始：

一点八

另请参见：

Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`static Instant`	`EPOCH` 为1970-01-01t00:00:00z时代即时常数。
`static Instant`	`MAX` 最大支持999999999 `Instant`，“1000000000-12-31t23:59:59. z。
`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)` 获得由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)` 获得 `Instant`实例从一个文本字符串，如 `2007-12-03T10:15:30.00Z`。
`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

- Field Detail
  - 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
```
    最大支持999999999 Instant，“1000000000-12-31t23:59:59. z。这可以被一个应用程序作为一个“遥远的未来”即时。
    这是比最大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至999999999范围内。例如，以下将导致在完全相同的即时：
```
即时ofepochsecond（3，1）；瞬间。ofepochsecond（4，- 999_999_999）；瞬间。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)
```
    获得 Instant实例从一个文本字符串，如 2007-12-03T10:15:30.00Z。
    该字符串必须是有效的即时和解析时使用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，然后通过调用作为参数传递this TemporalField.isSupportedBy(TemporalAccessor)得到此方法的结果。是否支持字段由字段确定。
    Specified by:
    
    isSupported 接口 TemporalAccessor
    
    参数
    
    field -现场检查null返回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，然后通过调用作为参数传递this TemporalUnit.isSupportedBy(Temporal)得到此方法的结果。是否支持单位是由单位确定的。
    Specified by:
    
    isSupported 接口 Temporal
    
    参数
    
    unit -检查单元，空返回false
    
    结果
    
    如果单位可以增加/减去，如果没有的话
  - range
```
public ValueRange range(TemporalField field)
```
    获取指定字段的有效值的范围。
    该范围对象表示字段的最小值和最大有效值。这一瞬间是用来提高返回范围的准确性。如果它是不可能返回的范围，因为字段不支持或其他一些原因，抛出一个异常。
    
    如果该字段是ChronoField然后查询执行。的supported fields将返回适当的范围的情况下。所有其他ChronoField实例将抛出一个UnsupportedTemporalTypeException。
    
    如果该字段是不是ChronoField，然后通过调用作为参数传递this TemporalField.rangeRefinedBy(TemporalAccessor)得到此方法的结果。是否可以得到范围是由字段确定的。
    
    Specified by:
    
    range 接口 TemporalAccessor
    
    参数
    
    field -现场查询范围，不为空
    
    结果
    
    字段的有效值的范围，而不是空值
    
    异常
    
    DateTimeException如果不能得到的领域范围
    
    UnsupportedTemporalTypeException如果字段不支持
  - get
```
public int get(TemporalField field)
```
    获取指定字段的值，从这一刻为 int。
    此查询此即时为指定字段的值。返回的值将始终在字段的有效值范围内。如果不可能返回值，因为字段不支持或其他原因，则抛出异常。
    
    如果该字段是ChronoField然后查询执行。的supported fields将基于此日期时间的有效值，除了INSTANT_SECONDS，太大的int抛DateTimeException。所有其他ChronoField实例将抛出一个UnsupportedTemporalTypeException。
    
    如果该字段是不是ChronoField，然后通过调用作为参数传递this TemporalField.getFrom(TemporalAccessor)得到此方法的结果。是否可以得到值，以及值表示的值，由字段确定。
    
    Specified by:
    
    get 接口 TemporalAccessor
    
    参数
    
    field -领域有，不空
    
    结果
    
    字段的值
    
    异常
    
    DateTimeException如果字段的值是不能获得或值不在字段的有效值范围内
    
    UnsupportedTemporalTypeException -如果字段不支持或值的范围超过一个 int
    
    ArithmeticException如果数值溢出时
  - getLong
```
public long getLong(TemporalField field)
```
    获取指定字段的值，从这一刻为 long。
    此查询此即时为指定字段的值。如果不可能返回值，因为字段不支持或其他原因，则抛出异常。
    
    如果该字段是ChronoField然后查询执行。的supported fields将基于此日期时间的有效值。所有其他ChronoField实例将抛出一个UnsupportedTemporalTypeException。
    
    如果该字段是不是ChronoField，然后通过调用作为参数传递this TemporalField.getFrom(TemporalAccessor)得到此方法的结果。是否可以得到值，以及值表示的值，由字段确定。
    
    Specified by:
    
    getLong 接口 TemporalAccessor
    
    参数
    
    field -领域有，不空
    
    结果
    
    字段的值
    
    异常
    
    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二值纳秒纳秒总数的措施。
    
    结果
    
    纳秒内第二，总是积极的，不超过999999999
  - with
```
public Instant with(TemporalAdjuster adjuster)
```
    返回此即时的调整后的副本。
    这将返回一个Instant，基于此，与即时调整。调整使用指定的调整器策略对象。阅读调整器的文档，了解将要做什么调整。
    
    这种方法的结果是通过调用指定的调节器，通过this作为论据的TemporalAdjuster.adjustInto(Temporal)方法得到的。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    with 接口 Temporal
    
    参数
    
    adjuster -调节器使用，不为空
    
    结果
    
    基于调整 this一 Instant，不空
    
    异常
    
    DateTimeException -如果调整不能
    
    ArithmeticException如果数值溢出时
  - with
```
public Instant with(TemporalField field,
                    long newValue)
```
    将此即时的副本与指定的字段设置为一个新值。
    这将返回一个Instant，在此基础上，对指定字段的值的变化。如果不可能设置值，因为字段不支持或其他原因，则抛出异常。
    
    如果该字段是ChronoField然后调整在这里实现。所支持的字段如下：
    - NANO_OF_SECOND -返回与指定的Instant纳米二。时代第二将是不变的。
    - MICRO_OF_SECOND -返回二由指定的微二乘以1000纳米的Instant取代。时代第二将是不变的。
    - MILLI_OF_SECOND -返回二由指定的毫秒二乘以1000000纳米的Instant取代。时代第二将是不变的。
    - INSTANT_SECONDS -返回与指定的时期的一个Instant二。第二纳米将保持不变。
    在所有的情况下，如果新的数值超出有效范围的领域，然后DateTimeException将抛出。
    
    所有其他ChronoField实例将抛出一个UnsupportedTemporalTypeException。
    
    如果该字段是不是ChronoField，然后通过调用作为参数传递this TemporalField.adjustInto(Temporal, long)得到此方法的结果。在这种情况下，字段决定是否以及如何调整即时。
    
    此实例是不可变的，不受此方法调用的影响。
    Specified by:
    
    with 接口 Temporal
    
    参数
    
    field -现场设置的结果，不为空
    
    newValue -场的结果中的新价值
    
    结果
    
    基于指定的字段设置一个 Instant this，不空
    
    异常
    
    DateTimeException -如果该字段不能设置
    
    UnsupportedTemporalTypeException如果字段不支持
    
    ArithmeticException如果数值溢出时
  - truncatedTo
```
public Instant truncatedTo(TemporalUnit unit)
```
    返回一份本 Instant截断到指定单位。
    截断即时返回一个字段小于指定的单位设置为零的原。计算基于UTC偏移的基础上看到toString的领域。例如，截断与MINUTES单元会轮到最近的分钟，设置秒和纳秒到零。
    
    单位必须有一个duration分成标准节长度无余。这包括所有提供的时间单位和其他单位ChronoUnit DAYS抛出一个异常。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    unit -单位截形，不为空
    
    结果
    
    随着时间的推移，截断这瞬间 Instant为主，不为空
    
    异常
    
    DateTimeException如果单位无效截断
    
    UnsupportedTemporalTypeException如果单位不支持
  - plus
```
public Instant plus(TemporalAmount amountToAdd)
```
    返回此即时的副本与指定的金额添加。
    这将返回一个Instant，在此基础上，用指定的添加量。量通常是Duration但可能是任何其他类型的TemporalAmount接口实现。
    
    计算委托量对象通过调用TemporalAmount.addTo(Temporal)。执行金额是免费在任何情况下它的愿望实现，但是它通常称为回plus(long, TemporalUnit)。咨询金额实现的文档，以确定是否可以成功添加。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    plus 接口 Temporal
    
    参数
    
    amountToAdd -添加量，不为空
    
    结果
    
    加上这一瞬间 Instant为主，不为空
    
    异常
    
    DateTimeException如果还不能
    
    ArithmeticException如果数值溢出时
  - plus
```
public Instant plus(long amountToAdd,
                    TemporalUnit unit)
```
    返回此即时的副本与指定的金额添加。
    这将返回一个Instant，基于此，在单元的添加量。如果它是不可能添加的量，因为该单元不支持或其他原因，则抛出异常。
    
    如果该字段是ChronoUnit然后添加在这里实现。所支持的字段如下：
    - NANOS -返回一个与指定数纳秒Instant添加。这相当于plusNanos(long)。
    - MICROS返回具有指定的微秒数Instant添加。这相当于plusNanos(long)的金额乘以1000。
    - MILLIS返回与指定的毫秒数Instant添加。这相当于plusNanos(long)的金额乘以1000000。
    - SECONDS -返回与指定的秒数Instant添加。这相当于plusSeconds(long)。
    - MINUTES -返回与指定的分钟数Instant添加。这相当于plusSeconds(long)的金额乘以60。
    - HOURS -返回与指定的小时数增加Instant。这相当于plusSeconds(long)的金额乘以3600。
    - HALF_DAYS -返回与指定数目的一半天Instant添加。这相当于plusSeconds(long)的金额乘以43200（12小时）。
    - DAYS -返回与指定的天数Instant添加。这相当于plusSeconds(long)的金额乘以86400（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为主，不为空
    
    异常
    
    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)。咨询文档的量的实现，以确定它是否可以成功地减去。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    minus 接口 Temporal
    
    参数
    
    amountToSubtract -减去的量，不为空
    
    结果
    
    用减法，在这瞬间 Instant为主，不为空
    
    异常
    
    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对象定义了用来获得结果的逻辑。阅读查询的文档，了解该方法的结果将是什么。
    
    这种方法的结果是通过调用指定的查询通过this作为论据的TemporalQuery.queryFrom(TemporalAccessor)方法得到的。
    
    Specified by:
    
    query 接口 TemporalAccessor
    
    参数类型
    
    R -结果的类型
    
    参数
    
    query -调用查询，不空
    
    结果
    
    查询结果，可以返回（由查询所定义）
    
    异常
    
    DateTimeException如果无法查询（查询所定义）
    
    ArithmeticException如果数值溢出时（由查询定义）
  - adjustInto
```
public Temporal adjustInto(Temporal temporal)
```
    调整指定的时间对象有这一瞬间。
    这将返回一个相同的可观察类型的时间对象，作为与即时改变的输入是相同的。
    
    调整是相当于用Temporal.with(TemporalField, long)两次，通过ChronoField.INSTANT_SECONDS和ChronoField.NANO_OF_SECOND的领域。
    
    在大多数情况下，更清晰的用Temporal.with(TemporalAdjuster)反向调用模式：
```
这两条线是等价的，但第二种方法是建议时间= thisinstant adjustinto（时间）；时间=（thisinstant）与时间；
```
    此实例是不可变的，不受此方法调用的影响。
    Specified by:
    
    adjustInto 接口 TemporalAdjuster
    
    参数
    
    temporal -调整目标对象，不为空
    
    结果
    
    调整后的对象，而不是空
    
    异常
    
    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)：
```
这两条线是等价的开始。直到（结束，秒）；金额=秒。之间（开始，结束）；
```
    的选择应基于使得代码更易读。
    计算中实现该方法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 -区结合，不为空
    
    结果
    
    从这个瞬间和指定区域形成的区域日期时间，而不是空
    
    异常
    
    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 -其他即时比较，不为空
    
    结果
    
    比较器的值，负的，如果少，积极的，如果更大
    
    异常
    
    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 otherInstant)
```
    检查此即时是否等于指定的即时。
    比较是基于瞬间的时间线的位置。
    
    重写：
    
    equals 方法重写，继承类 Object
    
    参数
    
    otherInstant -其他的瞬间，空返回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表示，不为空

Submit a bug or feature
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
Copyright © 1993, 2014, Oracle and/or its affiliates. All rights reserved.

Class Instant

时间尺度

Field Summary

方法摘要

Methods inherited from class java.lang.Object

Field Detail

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