Module java.base
Package java.time

Class Instant

java.lang.Object
java.time.Instant
所有已实现的接口:
Serializable, Comparable<Instant>, Temporal, TemporalAccessor, TemporalAdjuster
public final class Instant extends Object implements Temporal, TemporalAdjuster, Comparable<Instant>, Serializable
时间线上的瞬时点。

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

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

时间刻度

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

现代时间计量基于精确定义SI秒与铯原子跃迁之间的关系的原子钟。SI秒的长度被定义为非常接近一天的86400分之一。

不幸的是，随着地球的旋转，一天的长度会发生变化。此外，随着时间的推移，一天的平均长度正在变长，因为地球减速。因此，2012年的太阳日长度略长于86400 SI秒。任何给定日子的实际长度以及地球减速的程度都是不可预测的，只能通过测量来确定。UT1时间刻度捕捉了准确的日长，但只能在一天完成后的一段时间内获得。

UTC时间刻度是一种将UT1中的所有额外秒数捆绑成整秒的标准方法，称为闰秒。根据地球的旋转变化，可能会增加或减少闰秒。因此，UTC允许一天具有86399 SI秒或86401 SI秒，以确保一天与太阳保持对齐。

现代UTC时间刻度于1972年引入，引入了整秒的概念。在1958年至1972年期间，UTC的定义很复杂，存在微小的亚秒跃变和对虚拟秒长度的修改。截至2012年，正在讨论再次更改UTC定义的问题，可能是删除闰秒或引入其他更改。

鉴于上述准确时间计量的复杂性，此Java API定义了自己的时间刻度，即Java时间刻度。

Java时间刻度将每个日历日精确地划分为86400个单位，称为秒。这些秒可能与SI秒不同。它与事实上的国际民用时间刻度非常接近，该刻度的定义会不时发生变化。

Java时间刻度对时间线的不同部分有稍微不同的定义，每个部分都基于作为民用时间基础的共识国际时间刻度。每当国际协议的时间刻度被修改或替换时，必须为其定义Java时间刻度的新部分。每个部分必须满足以下要求：

  • Java时间刻度应与基础的国际民用时间刻度非常接近；
  • Java时间刻度应在每天中午精确匹配国际民用时间刻度；
  • Java时间刻度应与国际民用时间刻度有明确定义的关系。
截至2013年，Java时间刻度中有两个部分。

从1972-11-03（下面讨论确切的边界）直到另行通知的部分，共识的国际时间刻度是UTC（带有闰秒）。在此部分中，Java时间刻度与UTC-SLS相同。在没有闰秒的日子里，它与UTC相同。在有闰秒的日子里，闰秒均匀分布在当天的最后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。

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

实现要求:
此类是不可变的且线程安全的。
自:
1.8
参见:

  • Field Details

    • 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。

  • Method Details

    • now

      public static Instant now()
      从系统时钟获取当前瞬间。

      这将查询系统UTC时钟以获取当前瞬间。

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

      返回：
      使用系统时钟的当前瞬间，不为null

    • now

      public static Instant now(Clock clock)
      从指定时钟获取当前瞬间。

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

      使用此方法允许使用替代时钟进行测试。可以使用依赖注入引入替代时钟。

      参数：
      clock - 要使用的时钟，不为null
      返回：
      当前瞬间，不为null

    • ofEpochSecond

      public static Instant ofEpochSecond(long epochSecond)
      使用从1970-01-01T00:00:00Z时代开始的秒数获取Instant的实例。

      纳秒字段设置为零。

      参数：
      epochSecond - 从1970-01-01T00:00:00Z开始的秒数
      返回：
      一个瞬间，不为null
      抛出：
      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 - 秒数的纳秒调整，正数或负数
      返回：
      一个瞬间，不为null
      抛出：
      DateTimeException - 如果瞬间超过最大或最小瞬间
      ArithmeticException - 如果发生数值溢出

    • ofEpochMilli

      public static Instant ofEpochMilli(long epochMilli)
      使用从1970-01-01T00:00:00Z时代开始的毫秒数获取Instant的实例。

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

      参数：
      epochMilli - 从1970-01-01T00:00:00Z开始的毫秒数
      返回：
      一个瞬间，不为null

    • from

      public static Instant from(TemporalAccessor temporal)
      从时间对象获取Instant的实例。

      这基于指定的时间对象获取一个瞬间。 TemporalAccessor表示一组任意的日期和时间信息，此工厂将其转换为Instant的实例。

      转换提取INSTANT_SECONDS和NANO_OF_SECOND字段。

      此方法与函数接口TemporalQuery的签名匹配，允许通过方法引用Instant::from来使用它作为查询。

      参数：
      temporal - 要转换的时间对象，不为null
      返回：
      瞬间，不为null
      抛出：
      DateTimeException - 如果无法转换为Instant

    • parse

      public static Instant parse(CharSequence text)
      从文本字符串（如2007-12-03T10:15:30.00Z）获取Instant的实例。

      字符串必须表示UTC中的有效瞬间，并使用DateTimeFormatter.ISO_INSTANT进行解析。

      参数：
      text - 要解析的文本，不为null
      返回：
      解析的瞬间，不为null
      抛出：
      DateTimeParseException - 如果无法解析文本

    • isSupported

      public boolean isSupported(TemporalField field)
      检查是否支持指定的字段。

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

      如果字段是ChronoField，则在此处实现查询。支持的字段包括：

      • NANO_OF_SECOND
      • MICRO_OF_SECOND
      • MILLI_OF_SECOND
      • INSTANT_SECONDS
      所有其他ChronoField实例将返回false。

      如果字段不是ChronoField，则通过调用TemporalField.isSupportedBy(TemporalAccessor)传递this作为参数来获得此方法的结果。字段是否受支持由字段确定。

      在接口中指定：
      isSupported 在接口 TemporalAccessor
      参数：
      field - 要检查的字段，null返回false
      返回：
      如果此瞬间支持该字段，则为true，否则为false

    • isSupported

      public boolean isSupported(TemporalUnit unit)
      检查是否支持指定的单位。

      这将检查指定单位是否可以添加到此日期时间中或从中减去。如果为false，则调用plus(long, TemporalUnit)和minus方法将抛出异常。

      如果单位是ChronoUnit，则在此处实现查询。支持的单位包括：

      • NANOS
      • MICROS
      • MILLIS
      • SECONDS
      • MINUTES
      • HOURS
      • HALF_DAYS
      • DAYS
      所有其他ChronoUnit实例将返回false。

      如果单位不是ChronoUnit，则通过调用TemporalUnit.isSupportedBy(Temporal)传递this作为参数来获得此方法的结果。单位是否受支持由单位确定。

      在接口中指定：
      isSupported 在接口 Temporal
      参数：
      unit - 要检查的单位，null返回false
      返回：
      如果可以添加/减去单位，则为true，否则为false

    • range

      public ValueRange range(TemporalField field)
      获取指定字段的有效值范围。

      范围对象表示字段的最小和最大有效值。此瞬间用于增强返回范围的准确性。如果无法返回范围，因为不支持字段或出于其他原因，将抛出异常。

      如果字段是ChronoField，则在此处实现查询。支持的字段将返回适当的范围实例。所有其他ChronoField实例将抛出UnsupportedTemporalTypeException。

      如果字段不是ChronoField，则通过调用TemporalField.rangeRefinedBy(TemporalAccessor)传递this作为参数来获得此方法的结果。范围是否可获取由字段确定。

      在接口中指定：
      range 在接口 TemporalAccessor
      参数：
      field - 要查询范围的字段，不为null
      返回：
      字段的有效值范围，不为null
      抛出：
      DateTimeException - 如果无法获取字段的范围
      UnsupportedTemporalTypeException - 如果不支持该字段

    • get

      public int get(TemporalField field)
      获取此时刻指定字段的值作为int。

      查询此时刻指定字段的值。返回的值始终在字段的有效值范围内。如果由于字段不受支持或其他原因无法返回值，则会抛出异常。

      如果字段是一个ChronoField，则查询在此处实现。基于此日期时间，支持的字段将返回有效值，除了INSTANT_SECONDS，它太大而无法适应int并抛出DateTimeException。所有其他ChronoField实例将抛出UnsupportedTemporalTypeException。

      如果字段不是ChronoField，则通过调用TemporalField.getFrom(TemporalAccessor)并将this作为参数传递来获取此方法的结果。值是否可以获取以及值代表什么由字段决定。

      指定者：
      get 在接口 TemporalAccessor
      参数：
      field - 要获取的字段，不能为空
      返回：
      字段的值
      抛出：
      DateTimeException - 如果无法获取字段的值或值超出字段的有效值范围
      UnsupportedTemporalTypeException - 如果不支持该字段或值范围超过int
      ArithmeticException - 如果发生数值溢出

    • getLong

      public long getLong(TemporalField field)
      获取此时刻指定字段的值作为long。

      查询此时刻指定字段的值。如果由于字段不受支持或其他原因无法返回值，则会抛出异常。

      如果字段是一个ChronoField，则查询在此处实现。基于此日期时间，支持的字段将返回有效值。所有其他ChronoField实例将抛出UnsupportedTemporalTypeException。

      如果字段不是ChronoField，则通过调用TemporalField.getFrom(TemporalAccessor)并将this作为参数传递来获取此方法的结果。值是否可以获取以及值代表什么由字段决定。

      指定者：
      getLong 在接口 TemporalAccessor
      参数：
      field - 要获取的字段，不能为空
      返回：
      字段的值
      抛出：
      DateTimeException - 如果无法获取字段的值
      UnsupportedTemporalTypeException - 如果不支持该字段
      ArithmeticException - 如果发生数值溢出

    • getEpochSecond

      public long getEpochSecond()
      获取从Java纪元1970-01-01T00:00:00Z开始的秒数。

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

      返回：
      从1970-01-01T00:00:00Z纪元开始的秒数

    • getNano

      public int getNano()
      获取从秒开始沿时间线后面的纳秒数。

      秒后的纳秒值测量从getEpochSecond()返回的秒开始的总纳秒数。

      返回：
      秒内的纳秒数，始终为正值，不超过999,999,999

    • with

      public Instant with(TemporalAdjuster adjuster)
      返回此时刻的调整副本。

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

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

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

      指定者：
      with 在接口 Temporal
      参数：
      adjuster - 要使用的调整器，不能为空
      返回：
      基于this进行调整后的Instant，不为null
      抛出：
      DateTimeException - 如果无法进行调整
      ArithmeticException - 如果发生数值溢出

    • with

      public Instant with(TemporalField field, long newValue)
      返回具有指定字段设置为新值的此时刻的副本。

      返回一个Instant，基于此时刻，指定字段的值更改。如果由于字段不受支持或其他原因无法设置值，则会抛出异常。

      如果字段是一个ChronoField，则调整在此处实现。支持的字段的行为如下：

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

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

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

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

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

      指定者：
      with 在接口 Temporal
      参数：
      field - 要在结果中设置的字段，不能为空
      newValue - 结果中字段的新值
      返回：
      基于this的Instant，具有指定字段设置，不为null
      抛出：
      DateTimeException - 如果无法设置字段
      UnsupportedTemporalTypeException - 如果不支持该字段
      ArithmeticException - 如果发生数值溢出

    • truncatedTo

      public Instant truncatedTo(TemporalUnit unit)
      返回此Instant截断为指定单位的副本。

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

      单位必须具有可被标准日长度整除的持续时间，不得余数。这包括所有提供的时间单位在ChronoUnit和DAYS上。其他单位会抛出异常。

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

      参数：
      unit - 要截断为的单位，不能为空
      返回：
      基于此时刻的Instant，时间被截断，不为null
      抛出：
      DateTimeException - 如果单位无效以进行截断
      UnsupportedTemporalTypeException - 如果不支持该单位

    • plus

      public Instant plus(TemporalAmount amountToAdd)
      返回添加指定数量后的此时刻的副本。

      返回一个基于此时刻的Instant，并添加指定数量的副本。该数量通常是Duration，但也可以是实现TemporalAmount接口的任何其他类型。

      通过调用TemporalAmount.addTo(Temporal)将计算委托给数量对象。数量的实现可以以任何希望的方式实现添加，但通常会回调plus(long, TemporalUnit)。请查阅数量实现的文档，以确定是否可以成功添加。

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

      指定者：
      plus 在接口 Temporal
      参数：
      amountToAdd - 要添加的数量，不能为空
      返回：
      基于此时刻并进行了添加的Instant，不能为空
      抛出：
      DateTimeException - 如果无法进行添加
      ArithmeticException - 如果发生数值溢出

    • plus

      public Instant plus(long amountToAdd, TemporalUnit unit)
      返回添加指定数量后的此时刻的副本。

      返回一个基于此时刻的Instant，并以单位为单位添加的副本。如果无法添加数量，因为不支持该单位或出于其他原因，则会抛出异常。

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

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

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

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

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

      指定者：
      plus 在接口 Temporal
      参数：
      amountToAdd - 要添加到结果的单位数量，可以为负数
      unit - 要添加的数量的单位，不能为空
      返回：
      基于此时刻并进行了添加的Instant，不能为空
      抛出：
      DateTimeException - 如果无法进行添加
      UnsupportedTemporalTypeException - 如果不支持该单位
      ArithmeticException - 如果发生数值溢出

    • plusSeconds

      public Instant plusSeconds(long secondsToAdd)
      返回添加指定秒数后的此时刻的副本。

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

      参数：
      secondsToAdd - 要添加的秒数，可以为正数或负数
      返回：
      基于此时刻并进行了添加的Instant，不能为空
      抛出：
      DateTimeException - 如果结果超过最大或最小时刻
      ArithmeticException - 如果发生数值溢出

    • plusMillis

      public Instant plusMillis(long millisToAdd)
      返回添加指定毫秒数后的此时刻的副本。

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

      参数：
      millisToAdd - 要添加的毫秒数，可以为正数或负数
      返回：
      基于此时刻并进行了添加的Instant，不能为空
      抛出：
      DateTimeException - 如果结果超过最大或最小时刻
      ArithmeticException - 如果发生数值溢出

    • plusNanos

      public Instant plusNanos(long nanosToAdd)
      返回添加指定纳秒数后的此时刻的副本。

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

      参数：
      nanosToAdd - 要添加的纳秒数，可以为正数或负数
      返回：
      基于此时刻并进行了添加的Instant，不能为空
      抛出：
      DateTimeException - 如果结果超过最大或最小时刻
      ArithmeticException - 如果发生数值溢出

    • minus

      public Instant minus(TemporalAmount amountToSubtract)
      返回减去指定数量后的此时刻的副本。

      返回一个基于此时刻的Instant，并减去指定数量的副本。该数量通常是Duration，但也可以是实现TemporalAmount接口的任何其他类型。

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

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

      指定者：
      minus 在接口 Temporal
      参数：
      amountToSubtract - 要减去的数量，不能为空
      返回：
      基于此时刻并进行了减法的Instant，不能为空
      抛出：
      DateTimeException - 如果无法进行减法
      ArithmeticException - 如果发生数值溢出

    • minus

      public Instant minus(long amountToSubtract, TemporalUnit unit)
      返回减去指定数量后的此时刻的副本。

      返回一个基于此时刻的Instant，并以单位为单位减去的副本。如果无法减去数量，因为不支持该单位或出于其他原因，则会抛出异常。

      此方法等同于plus(long, TemporalUnit)，其数量为负。有关添加（因此减法）的工作原理的完整描述，请参阅该方法。

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

      指定者：
      minus 在接口 Temporal
      参数：
      amountToSubtract - 要从结果中减去的单位数量，可以为负数
      unit - 要减去的数量的单位，不能为空
      返回：
      基于此时刻并进行了减法的Instant，不能为空
      抛出：
      DateTimeException - 如果无法进行减法
      UnsupportedTemporalTypeException - 如果不支持该单位
      ArithmeticException - 如果发生数值溢出

    • minusSeconds

      public Instant minusSeconds(long secondsToSubtract)
      返回减去指定秒数后的此时刻的副本。

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

      参数:
      secondsToSubtract - 要减去的秒数，可以是正数或负数
      返回:
      基于此时刻并减去指定秒数的Instant，不为null
      抛出:
      DateTimeException - 如果结果超过最大或最小时刻
      ArithmeticException - 如果发生数值溢出

    • minusMillis

      public Instant minusMillis(long millisToSubtract)
      返回减去指定毫秒数后的此时刻的副本。

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

      参数:
      millisToSubtract - 要减去的毫秒数，可以是正数或负数
      返回:
      基于此时刻并减去指定毫秒数的Instant，不为null
      抛出:
      DateTimeException - 如果结果超过最大或最小时刻
      ArithmeticException - 如果发生数值溢出

    • minusNanos

      public Instant minusNanos(long nanosToSubtract)
      返回减去指定纳秒数后的此时刻的副本。

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

      参数:
      nanosToSubtract - 要减去的纳秒数，可以是正数或负数
      返回:
      基于此时刻并减去指定纳秒数的Instant，不为null
      抛出:
      DateTimeException - 如果结果超过最大或最小时刻
      ArithmeticException - 如果发生数值溢出

    • query

      public <R> R query(TemporalQuery<R> query)
      使用指定的查询对此时刻进行查询。

      使用指定的查询策略对象对此时刻进行查询。 TemporalQuery对象定义了用于获取结果的逻辑。阅读查询的文档以了解此方法的结果。

      此方法的结果是通过在指定的查询上调用TemporalQuery.queryFrom(TemporalAccessor)方法并将this作为参数传递来获得的。

      指定者:
      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)来反转调用模式更清晰：

         // 这两行是等效的，但建议使用第二种方法
   temporal = thisInstant.adjustInto(temporal);
   temporal = temporal.with(thisInstant);

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

      指定者:
      adjustInto 在接口 TemporalAdjuster
      参数:
      temporal - 要调整的目标对象，不为null
      返回:
      调整后的对象，不为null
      抛出:
      DateTimeException - 如果无法进行调整
      ArithmeticException - 如果发生数值溢出

    • until

      public long until(Temporal endExclusive, TemporalUnit unit)
      根据指定单位计算到另一个时刻的时间量。

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

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

         // 这两行是等效的
   amount = start.until(end, SECONDS);
   amount = SECONDS.between(start, end);
      应根据哪种方式使代码更易读来进行选择。

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

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

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

      指定者:
      until 在接口 Temporal
      参数:
      endExclusive - 结束日期（不包括），将其转换为Instant，不为null
      unit - 用于测量时间量的单位，不为null
      返回:
      此时刻与结束时刻之间的时间量
      抛出:
      DateTimeException - 如果无法计算时间量，或结束时间无法转换为Instant
      UnsupportedTemporalTypeException - 如果不支持该单位
      ArithmeticException - 如果发生数值溢出

    • atOffset

      public OffsetDateTime atOffset(ZoneOffset offset)
      将此时刻与偏移量组合以创建OffsetDateTime。

      返回从UTC/Greenwich的此时刻形成的OffsetDateTime。如果此时刻太大而无法适应偏移日期时间，则会抛出异常。

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

      参数:
      offset - 要组合的偏移量，不为null
      返回:
      从此时刻和指定偏移量形成的偏移日期时间，不为null
      抛出:
      DateTimeException - 如果结果超过支持的范围

    • atZone

      public ZonedDateTime atZone(ZoneId zone)
      将此时刻与时区组合以创建ZonedDateTime。

      返回从此时刻形成的具有指定时区的ZonedDateTime。如果此时刻太大而无法适应分区日期时间，则会抛出异常。

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

      参数:
      zone - 要组合的时区，不为null
      返回:
      从此时刻和指定时区形成的分区日期时间，不为null
      抛出:
      DateTimeException - 如果结果超过支持的范围

    • toEpochMilli

      public long toEpochMilli()
      将此时刻转换为从1970-01-01T00:00:00Z时代开始的毫秒数。

      如果此时刻代表时间线上太远的未来或过去的点，以至于无法适应long毫秒数，则会抛出异常。

      如果此时刻的精度大于毫秒，则转换将丢弃任何多余的精度信息，就好像纳秒数按一百万进行整数除法。

      返回:
      从1970-01-01T00:00:00Z时代开始的毫秒数
      抛出:
      ArithmeticException - 如果发生数值溢出

    • compareTo

      public int compareTo(Instant otherInstant)
      比较此时刻与指定时刻。

      比较基于时刻的时间线位置。它是“与equals一致”的，如Comparable定义的。

      指定者:
      compareTo 在接口 Comparable<Instant>
      参数:
      otherInstant - 要比较的另一个时刻，不能为空
      返回:
      比较器值，如果此时刻在otherInstant之前，则小于零，如果它们相等，则为零，如果此时刻在otherInstant之后，则大于零
      抛出:
      NullPointerException - 如果otherInstant为null
      参见:

    • isAfter

      public boolean isAfter(Instant otherInstant)
      检查此时刻是否在指定时刻之后。

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

      参数:
      otherInstant - 要比较的另一个时刻，不能为空
      返回:
      如果此时刻在指定时刻之后，则为true
      抛出:
      NullPointerException - 如果otherInstant为null

    • isBefore

      public boolean isBefore(Instant otherInstant)
      检查此时刻是否在指定时刻之前。

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

      参数:
      otherInstant - 要比较的另一个时刻，不能为空
      返回:
      如果此时刻在指定时刻之前，则为true
      抛出:
      NullPointerException - 如果otherInstant为null

    • equals

      public boolean equals(Object other)
      检查此时刻是否等于指定时刻。

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

      覆盖:
      equals 在类 Object
      参数:
      other - 另一个时刻，null返回false
      返回:
      如果另一个时刻等于此时刻，则为true
      参见:

    • hashCode

      public int hashCode()
      返回此时刻的哈希码。
      覆盖:
      hashCode 在类 Object
      返回:
      适当的哈希码
      参见:

    • toString

      public String toString()
      使用ISO-8601表示返回此时刻的字符串表示。

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

      覆盖:
      toString 在类 Object
      返回:
      此时刻的ISO-8601表示，不能为空