模块 java.base
包 java.time

类 OffsetDateTime

java.lang.Object
java.time.OffsetDateTime
所有已实现的接口：
Serializable , Comparable<OffsetDateTime> , Temporal , TemporalAccessor , TemporalAdjuster
public final class OffsetDateTime extends Object implements Temporal , TemporalAdjuster , Comparable <OffsetDateTime >, Serializable
在 ISO-8601 日历系统中与 UTC/Greenwich 有偏移的日期时间，例如 2007-12-03T10:15:30+01:00 。

OffsetDateTime 是具有偏移量的日期时间的不可变表示。此类存储所有日期和时间字段，精确到纳秒，以及与 UTC/格林威治的偏移量。例如，值“2007 年 10 月 2 日 13:45:30.123456789 +02:00”可以存储在 OffsetDateTime 中。

OffsetDateTime、ZonedDateTime 和 Instant 都将时间线上的瞬间存储为纳秒精度。 Instant 是最简单的，只是代表瞬间。 OffsetDateTime 将 UTC/Greenwich 的偏移量添加到瞬间，这允许获取本地日期时间。 ZonedDateTime 添加了完整的时区规则。

ZonedDateTime 或 Instant 旨在为更简单的应用程序中的数据建模。在更详细地建模日期时间概念时，或者在与数据库或网络协议进行通信时，可以使用此类。

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

实现要求：
这个类是不可变的和线程安全的。
自从：
1.8
参见：

  • 字段详细信息

    • MIN

      public static final OffsetDateTime  MIN
      支持的最小值 OffsetDateTime，'-999999999-01-01T00:00:00+18:00'。这是最大偏移量中最小日期开始时的午夜本地日期时间（较大的偏移量在时间线上较早）。这结合了 LocalDateTime.MIN 和 ZoneOffset.MAX 。这可以被应用程序用作“很久以前”的日期时间。

    • MAX

      public static final OffsetDateTime  MAX
      最大支持 OffsetDateTime ，'+999999999-12-31T23:59:59.999999999-18:00'。这是最小偏移量中最大日期结束时午夜之前的本地日期时间（较大的负偏移量在时间轴上较晚）。这结合了 LocalDateTime.MAX 和 ZoneOffset.MIN 。这可以被应用程序用作“遥远的未来”日期时间。

  • 方法详情

    • timeLineOrder

      public static Comparator <OffsetDateTime > timeLineOrder()
      获取一个比较器，该比较器仅基于瞬间比较两个 OffsetDateTime 实例。

      此方法与 compareTo(java.time.OffsetDateTime) 中的比较不同，因为它只比较基础瞬间。

      返回：
      按时间顺序比较的比较器
      参见：

    • now

      public static OffsetDateTime  now()
      从默认时区的系统时钟获取当前日期时间。

      这将查询默认时区中的 system clock 以获取当前日期时间。偏移量将从时钟中的时区计算。

      使用此方法将阻止使用备用时钟进行测试的能力，因为时钟是硬编码的。

      返回：
      使用系统时钟的当前日期时间，不为空

    • now

      public static OffsetDateTime  now(ZoneId  zone)
      从指定时区的系统时钟获取当前日期时间。

      这将查询 system clock 以获取当前日期时间。指定时区避免了对默认时区的依赖。偏移量将从指定的时区计算。

      使用此方法将阻止使用备用时钟进行测试的能力，因为时钟是硬编码的。

      参数：
      zone - 要使用的区域 ID，不为空
      返回：
      使用系统时钟的当前日期时间，不为空

    • now

      public static OffsetDateTime  now(Clock  clock)
      从指定时钟获取当前日期时间。

      这将查询指定的时钟以获取当前日期时间。偏移量将从时钟中的时区计算。

      使用此方法允许使用备用时钟进行测试。可以使用 dependency injection 引入备用时钟。

      参数：
      clock - 使用的时钟，不为空
      返回：
      当前日期时间，不为空

    • of

      public static OffsetDateTime  of(LocalDate  date, LocalTime  time, ZoneOffset  offset)
      从日期、时间和偏移量中获取 OffsetDateTime 的实例。

      这将创建一个具有指定本地日期、时间和偏移量的偏移日期时间。

      参数：
      date - 本地日期，不为空
      time - 当地时间，不为空
      offset - 区域偏移量，不为空
      返回：
      偏移日期时间，不为空

    • of

      public static OffsetDateTime  of(LocalDateTime  dateTime, ZoneOffset  offset)
      从日期时间和偏移量获取 OffsetDateTime 的实例。

      这将创建一个具有指定本地日期时间和偏移量的偏移日期时间。

      参数：
      dateTime - 本地日期时间，不为空
      offset - 区域偏移量，不为空
      返回：
      偏移日期时间，不为空

    • of

      public static OffsetDateTime  of(int year, int month, int dayOfMonth, int hour, int minute, int second, int nanoOfSecond, ZoneOffset  offset)
      从年、月、日、小时、分钟、秒、纳秒和偏移量中获取 OffsetDateTime 的实例。

      这将创建一个具有七个指定字段的偏移日期时间。

      此方法主要用于编写测试用例。非测试代码通常会使用其他方法来创建偏移时间。 LocalDateTime 有五个额外的使用更少参数的等效工厂方法的便利变体。此处未提供它们以减少 API 的占用空间。

      参数：
      year - 表示的年份，从 MIN_YEAR 到 MAX_YEAR
      month - 要表示的月份，从 1（一月）到 12（十二月）
      dayOfMonth - 要表示的日期，从 1 到 31
      hour - 要表示的小时数，从 0 到 23
      minute - 要表示的分钟数，从 0 到 59
      second - 表示的秒数，从 0 到 59
      nanoOfSecond - 表示的纳秒，从 0 到 999,999,999
      offset - 区域偏移量，不为空
      返回：
      偏移日期时间，不为空
      抛出：
      DateTimeException - 如果任何字段的值超出范围，或者如果月份日期对于月份年份无效

    • ofInstant

      public static OffsetDateTime  ofInstant(Instant  instant, ZoneId  zone)
      从 Instant 和区域 ID 获取 OffsetDateTime 的实例。

      这将创建一个与指定时刻具有相同时刻的偏移日期时间。查找与 UTC/格林威治的偏移量很简单，因为每个时刻只有一个有效偏移量。

      参数：
      instant - 创建日期时间的时刻，不为空
      zone - 时区，可能是一个偏移量，不为空
      返回：
      偏移日期时间，不为空
      抛出：
      DateTimeException - 如果结果超出支持的范围

    • from

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

      这将根据指定的时间获得偏移日期时间。 TemporalAccessor 表示一组任意的日期和时间信息，该工厂将其转换为 OffsetDateTime 的一个实例。

      转换将首先从时间对象中获取一个ZoneOffset。然后它将尝试获取 LocalDateTime ，必要时回落到 Instant 。结果将是 ZoneOffset 与 LocalDateTime 或 Instant 的组合。允许实现执行优化，例如访问与相关对象等效的那些字段。

      此方法与功能接口 TemporalQuery 的签名相匹配，允许它通过方法参考 OffsetDateTime::from 用作查询。

      参数：
      temporal - 要转换的时间对象，不为空
      返回：
      偏移日期时间，不为空
      抛出：
      DateTimeException - 如果无法转换为 OffsetDateTime

    • parse

      public static OffsetDateTime  parse(CharSequence  text)
      从 2007-12-03T10:15:30+01:00 等文本字符串中获取 OffsetDateTime 的实例。

      该字符串必须表示有效的日期时间，并使用 DateTimeFormatter.ISO_OFFSET_DATE_TIME 进行解析。

      参数：
      text - 要解析的文本，例如“2007-12-03T10:15:30+01:00”，不为空
      返回：
      解析的偏移日期时间，不为空
      抛出：
      DateTimeParseException - 如果无法解析文本

    • parse

      public static OffsetDateTime  parse(CharSequence  text, DateTimeFormatter  formatter)
      使用特定格式化程序从文本字符串中获取 OffsetDateTime 的实例。

      使用格式化程序解析文本，返回日期时间。

      参数：
      text - 要解析的文本，不为空
      formatter - 要使用的格式化程序，不为空
      返回：
      解析的偏移日期时间，不为空
      抛出：
      DateTimeParseException - 如果无法解析文本

    • isSupported

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

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

      如果该字段是一个ChronoField 那么查询就在这里实现。支持的字段是：

      • NANO_OF_SECOND
      • NANO_OF_DAY
      • MICRO_OF_SECOND
      • MICRO_OF_DAY
      • MILLI_OF_SECOND
      • MILLI_OF_DAY
      • SECOND_OF_MINUTE
      • SECOND_OF_DAY
      • MINUTE_OF_HOUR
      • MINUTE_OF_DAY
      • HOUR_OF_AMPM
      • CLOCK_HOUR_OF_AMPM
      • HOUR_OF_DAY
      • CLOCK_HOUR_OF_DAY
      • AMPM_OF_DAY
      • DAY_OF_WEEK
      • ALIGNED_DAY_OF_WEEK_IN_MONTH
      • ALIGNED_DAY_OF_WEEK_IN_YEAR
      • DAY_OF_MONTH
      • DAY_OF_YEAR
      • EPOCH_DAY
      • ALIGNED_WEEK_OF_MONTH
      • ALIGNED_WEEK_OF_YEAR
      • MONTH_OF_YEAR
      • PROLEPTIC_MONTH
      • YEAR_OF_ERA
      • YEAR
      • ERA
      • INSTANT_SECONDS
      • OFFSET_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
      • WEEKS
      • MONTHS
      • YEARS
      • DECADES
      • CENTURIES
      • MILLENNIA
      • ERAS
      所有其他 ChronoUnit 实例将返回 false。

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

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

    • range

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

      范围对象表示字段的最小和最大有效值。此日期时间用于提高返回范围的准确性。如果由于不支持该字段或其他原因而无法返回范围，则会抛出异常。

      如果该字段是一个ChronoField 那么查询就在这里实现。 supported fields 将返回适当的范围实例。所有其他 ChronoField 实例将抛出 UnsupportedTemporalTypeException 。

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

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

    • get

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

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

      如果该字段是一个ChronoField 那么查询就在这里实现。 supported fields 将根据此日期时间返回有效值，除了 NANO_OF_DAY 、 MICRO_OF_DAY 、 EPOCH_DAY 、 PROLEPTIC_MONTH 和 INSTANT_SECONDS 太大而无法放入 int 并抛出 UnsupportedTemporalTypeException 。所有其他 ChronoField 实例将抛出 UnsupportedTemporalTypeException 。

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

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

    • getLong

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

      这将在此日期时间查询指定字段的值。如果由于不支持该字段或其他原因而无法返回该值，则会抛出异常。

      如果该字段是一个ChronoField 那么查询就在这里实现。 supported fields 将根据此日期时间返回有效值。所有其他 ChronoField 实例将抛出 UnsupportedTemporalTypeException 。

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

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

    • getOffset

      public ZoneOffset  getOffset()
      获取区域偏移量，例如“+01:00”。

      这是本地日期时间与 UTC/格林威治时间的偏移量。

      返回：
      区域偏移量，不为空

    • withOffsetSameLocal

      public OffsetDateTime  withOffsetSameLocal(ZoneOffset  offset)
      返回具有指定偏移量的此 OffsetDateTime 的副本，确保结果具有相同的本地日期时间。

      此方法返回一个具有相同 LocalDateTime 和指定 ZoneOffset 的对象。不需要或执行任何计算。例如，如果此时表示 2007-12-03T10:30+02:00 并且指定的偏移量为 +03:00 ，则此方法将返回 2007-12-03T10:30+03:00 。

      要考虑偏移量之间的差异并调整时间字段，请使用 withOffsetSameInstant(java.time.ZoneOffset) 。

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

      参数：
      offset - 要更改为的区域偏移量，不为空
      返回：
      基于此日期时间的 OffsetDateTime 具有请求的偏移量，不为空

    • withOffsetSameInstant

      public OffsetDateTime  withOffsetSameInstant(ZoneOffset  offset)
      返回具有指定偏移量的此 OffsetDateTime 的副本，确保结果在同一时刻。

      此方法返回一个对象，该对象具有指定的 ZoneOffset 和 LocalDateTime，并根据两个偏移量之间的差异进行了调整。这将导致旧对象和新对象代表同一时刻。这对于在不同的偏移量中查找本地时间很有用。例如，如果此时表示 2007-12-03T10:30+02:00 并且指定的偏移量为 +03:00 ，则此方法将返回 2007-12-03T11:30+03:00 。

      要在不调整本地时间的情况下更改偏移量，请使用 withOffsetSameLocal(java.time.ZoneOffset) 。

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

      参数：
      offset - 要更改为的区域偏移量，不为空
      返回：
      基于此日期时间的 OffsetDateTime 具有请求的偏移量，不为空
      抛出：
      DateTimeException - 如果结果超出支持的日期范围

    • toLocalDateTime

      public LocalDateTime  toLocalDateTime()
      获取此日期时间的 LocalDateTime 部分。

      这将返回一个 LocalDateTime 与此日期时间具有相同的年、月、日和时间。

      返回：
      此日期时间的本地日期时间部分，不为空

    • toLocalDate

      public LocalDate  toLocalDate()
      获取此日期时间的 LocalDate 部分。

      这将返回与此日期时间具有相同年月日的 LocalDate。

      返回：
      此日期时间的日期部分，不为空

    • getYear

      public int getYear()
      获取年份字段。

      此方法返回年份的原始 int 值。

      根据 get(YEAR)，此方法返回的年份是预估的。要获取年代，请使用 get(YEAR_OF_ERA) 。

      返回：
      年份，从 MIN_YEAR 到 MAX_YEAR

    • getMonthValue

      public int getMonthValue()
      获取从 1 到 12 的月份字段。

      此方法将月份作为 int 从 1 到 12 返回。如果通过调用 getMonth() 使用枚举 Month ，应用程序代码通常会更清晰。

      返回：
      一年中的月份，从 1 到 12
      参见：

    • getMonth

      public Month  getMonth()
      使用 Month 枚举获取月份字段。

      此方法返回月份的枚举 Month 。这避免混淆 int 值的含义。如果您需要访问原始 int 值，则枚举会提供 int value 。

      返回：
      月份，不为空
      参见：

    • getDayOfMonth

      public int getDayOfMonth()
      获取日期字段。

      此方法返回日期的原始 int 值。

      返回：
      一个月中的第几天，从 1 到 31

    • getDayOfYear

      public int getDayOfYear()
      获取年份字段。

      此方法返回一年中第几天的原始 int 值。

      返回：
      一年中的第几天，从 1 到 365，或闰年为 366

    • getDayOfWeek

      public DayOfWeek  getDayOfWeek()
      获取星期字段，它是一个枚举 DayOfWeek 。

      此方法返回星期几的枚举 DayOfWeek 。这避免混淆 int 值的含义。如果您需要访问原始 int 值，则枚举会提供 int value 。

      可以从 DayOfWeek 获得更多信息。这包括值的文本名称。

      返回：
      星期几，不为空

    • toLocalTime

      public LocalTime  toLocalTime()
      获取此日期时间的 LocalTime 部分。

      这将返回一个 LocalTime 与此日期时间具有相同的小时、分钟、秒和纳秒。

      返回：
      此日期时间的时间部分，不为空

    • getHour

      public int getHour()
      获取一天中的小时字段。
      返回：
      一天中的小时，从 0 到 23

    • getMinute

      public int getMinute()
      获取分钟字段。
      返回：
      小时的分钟数，从 0 到 59

    • getSecond

      public int getSecond()
      获取秒字段。
      返回：
      秒，从 0 到 59

    • getNano

      public int getNano()
      获取纳秒级字段。
      返回：
      纳秒，从 0 到 999,999,999

    • with

      public OffsetDateTime  with(TemporalAdjuster  adjuster)
      返回此日期时间的调整副本。

      这将返回一个 OffsetDateTime ，基于这个，调整了日期时间。使用指定的调整器策略对象进行调整。阅读调整器的文档以了解将进行的调整。

      一个简单的调整器可能只是设置其中一个字段，例如年份字段。更复杂的调节器可能会将日期设置为该月的最后一天。 TemporalAdjusters 中提供了一系列常用调整。其中包括查找“本月的最后一天”和“下周三”。关键日期时间类还实现了 TemporalAdjuster 接口，例如 Month 和 MonthDay 。调节器负责处理特殊情况，例如不同长度的月份和闰年。

      例如，此代码返回 7 月最后一天的日期：

       import static java.time.Month.*;
 import static java.time.temporal.TemporalAdjusters.*;

 result = offsetDateTime.with(JULY).with(lastDayOfMonth());

      类 LocalDate 、 LocalTime 和 ZoneOffset 实现 TemporalAdjuster ，因此该方法可用于更改日期、时间或偏移量：

       result = offsetDateTime.with(date);
 result = offsetDateTime.with(time);
 result = offsetDateTime.with(offset);

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

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

      指定者：
      with 在接口 Temporal 中
      参数：
      adjuster - 要使用的调节器，不为空
      返回：
      OffsetDateTime 基于 this 并进行了调整，不为空
      抛出：
      DateTimeException - 如果无法进行调整
      ArithmeticException - 如果发生数字溢出

    • with

      public OffsetDateTime  with(TemporalField  field, long newValue)
      返回此日期时间的副本，并将指定字段设置为新值。

      这将返回一个 OffsetDateTime ，基于这个，指定字段的值已更改。这可用于更改任何受支持的字段，例如年、月或月中的某天。如果无法设置该值，因为不支持该字段或出于其他原因，则会抛出异常。

      在某些情况下，更改指定字段会导致生成的日期时间无效，例如将月份从 1 月 31 日更改为 2 月会使日期无效。在这种情况下，该字段负责解析日期。通常它会选择之前的有效日期，在本例中为 2 月的最后一个有效日期。

      如果该字段是 ChronoField 则在此处执行调整。

      INSTANT_SECONDS 字段将返回具有指定时刻的日期时间。偏移量和纳秒级不变。如果新的瞬时值超出有效范围，则会抛出 DateTimeException。

      OFFSET_SECONDS 字段将返回具有指定偏移量的日期时间。本地日期时间未更改。如果新的偏移值超出有效范围，则会抛出 DateTimeException。

      另一个 supported fields 将按照 LocalDateTime 上的匹配方法运行。在这种情况下，偏移量不是计算的一部分，并且不会改变。

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

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

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

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

    • withYear

      public OffsetDateTime  withYear(int year)
      返回此 OffsetDateTime 的副本，并更改年份。

      时间和偏移量不影响计算，结果相同。如果当年的日期无效，则更改为该月的最后一个有效日期。

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

      参数：
      year - 在结果中设置的年份，从 MIN_YEAR 到 MAX_YEAR
      返回：
      OffsetDateTime 基于此日期时间和请求的年份，不为空
      抛出：
      DateTimeException - 如果年份值无效

    • withMonth

      public OffsetDateTime  withMonth(int month)
      返回此 OffsetDateTime 的副本，其中更改了月份。

      时间和偏移量不影响计算，结果相同。如果当年的日期无效，则更改为该月的最后一个有效日期。

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

      参数：
      month - 在结果中设置的月份，从 1（一月）到 12（十二月）
      返回：
      OffsetDateTime 基于此日期时间和请求的月份，不为空
      抛出：
      DateTimeException - 如果月份值无效

    • withDayOfMonth

      public OffsetDateTime  withDayOfMonth(int dayOfMonth)
      返回此 OffsetDateTime 的副本，其中日期已更改。

      如果生成的 OffsetDateTime 无效，则抛出异常。时间和偏移量不影响计算，结果相同。

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

      参数：
      dayOfMonth - 在结果中设置的日期，从 1 到 28-31
      返回：
      OffsetDateTime 基于此日期时间和请求的日期，不为空
      抛出：
      DateTimeException - 如果月日值无效，或者月日对于月年无效

    • withDayOfYear

      public OffsetDateTime  withDayOfYear(int dayOfYear)
      返回此 OffsetDateTime 的副本，其中日期已更改。

      时间和偏移量不影响计算，结果相同。如果生成的 OffsetDateTime 无效，则抛出异常。

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

      参数：
      dayOfYear - 在结果中设置的日期，从 1 到 365-366
      返回：
      OffsetDateTime 基于此日期和请求的日期，不为空
      抛出：
      DateTimeException - 如果年份值无效，或者年份值对于该年无效

    • withHour

      public OffsetDateTime  withHour(int hour)
      返回此 OffsetDateTime 的副本，其中更改了一天中的小时数。

      日期和偏移量不影响计算，结果相同。

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

      参数：
      hour - 在结果中设置的小时数，从 0 到 23
      返回：
      OffsetDateTime 基于此日期时间和请求的时间，不为空
      抛出：
      DateTimeException - 如果小时值无效

    • withMinute

      public OffsetDateTime  withMinute(int minute)
      返回此 OffsetDateTime 的副本，并更改了分钟。

      日期和偏移量不影响计算，结果相同。

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

      参数：
      minute - 在结果中设置的分钟数，从 0 到 59
      返回：
      OffsetDateTime 基于此日期时间和请求的分钟，不为空
      抛出：
      DateTimeException - 如果分钟值无效

    • withSecond

      public OffsetDateTime  withSecond(int second)
      返回此 OffsetDateTime 的副本，并更改了秒数。

      日期和偏移量不影响计算，结果相同。

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

      参数：
      second - 在结果中设置的秒数，从 0 到 59
      返回：
      基于此日期时间的 OffsetDateTime 和请求的秒数，不为空
      抛出：
      DateTimeException - 如果第二个值无效

    • withNano

      public OffsetDateTime  withNano(int nanoOfSecond)
      返回此 OffsetDateTime 的副本，并更改了纳秒级。

      日期和偏移量不影响计算，结果相同。

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

      参数：
      nanoOfSecond - 在结果中设置的纳秒，从 0 到 999,999,999
      返回：
      一个 OffsetDateTime 基于这个日期时间和请求的纳秒，不为空
      抛出：
      DateTimeException - 如果纳米值无效

    • truncatedTo

      public OffsetDateTime  truncatedTo(TemporalUnit  unit)
      返回此 OffsetDateTime 的副本，时间被截断。

      截断返回原始日期时间的副本，其中小于指定单位的字段设置为零。例如，使用 minutes 单位截断会将秒和纳秒字段设置为零。

      该单位必须有一个 duration，它可以划分为一个标准日的长度，没有余数。这包括 ChronoUnit 和 DAYS 上所有提供的时间单位。其他单位抛出异常。

      偏移量不影响计算，结果相同。

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

      参数：
      unit - 要截断的单位，不为空
      返回：
      一个 OffsetDateTime 基于这个日期时间，时间被截断，不为空
      抛出：
      DateTimeException - 如果无法截断
      UnsupportedTemporalTypeException - 如果不支持该单元

    • plus

      public OffsetDateTime  plus(TemporalAmount  amountToAdd)
      返回添加了指定数量的此日期时间的副本。

      这将返回一个 OffsetDateTime ，基于这个，添加了指定的数量。数量通常是 Period 或 Duration 但可以是实现 TemporalAmount 接口的任何其他类型。

      通过调用 TemporalAmount.addTo(Temporal) 将计算委托给金额对象。金额实现可以自由地以任何它希望的方式实现加法，但是它通常会回调 plus(long, TemporalUnit) 。查阅amount实现的文档，判断是否可以添加成功。

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

      指定者：
      plus 在接口 Temporal 中
      参数：
      amountToAdd - 添加的数量，不为空
      返回：
      基于此日期时间的 OffsetDateTime 添加，不为空
      抛出：
      DateTimeException - 如果无法添加
      ArithmeticException - 如果发生数字溢出

    • plus

      public OffsetDateTime  plus(long amountToAdd, TemporalUnit  unit)
      返回添加了指定数量的此日期时间的副本。

      这将返回一个 OffsetDateTime ，基于这个，加上以单位表示的数量。如果由于不支持该单位或其他原因而无法添加金额，则会抛出异常。

      如果该字段是 ChronoUnit ，则加法由 LocalDateTime.plus(long, TemporalUnit) 实现。偏移量不是计算的一部分，结果不会改变。

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

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

      指定者：
      plus 在接口 Temporal 中
      参数：
      amountToAdd - 添加到结果的单位数量，可能为负数
      unit - 添加量的单位，不为空
      返回：
      基于此日期时间的 OffsetDateTime 添加了指定的数量，不为空
      抛出：
      DateTimeException - 如果无法添加
      UnsupportedTemporalTypeException - 如果不支持该单元
      ArithmeticException - 如果发生数字溢出

    • plusYears

      public OffsetDateTime  plusYears(long years)
      返回此 OffsetDateTime 的副本，并添加了指定的年数。

      此方法分三步将指定金额添加到年字段：

      1. 将输入年份添加到年份字段
      2. 检查结果日期是否无效
      3. 如有必要，将日期调整为最后一个有效日期

      例如，2008-02-29（闰年）加上一年将导致无效日期 2009-02-29（标准年）。不是返回无效结果，而是选择该月的最后一个有效日期 2009-02-28。

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

      参数：
      years - 添加的年份，可能为负
      返回：
      基于此日期时间的 OffsetDateTime 添加了年份，不为空
      抛出：
      DateTimeException - 如果结果超出支持的日期范围

    • plusMonths

      public OffsetDateTime  plusMonths(long months)
      返回此 OffsetDateTime 的副本，并添加了指定的月数。

      此方法分三步将指定金额添加到月份字段：

      1. 将输入月份添加到月份字段
      2. 检查结果日期是否无效
      3. 如有必要，将日期调整为最后一个有效日期

      例如，2007-03-31 加上一个月将导致无效日期 2007-04-31。不是返回无效结果，而是选择该月的最后一个有效日期 2007-04-30。

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

      参数：
      months - 添加的月份，可能为负
      返回：
      基于此日期时间的 OffsetDateTime 添加了月份，不为空
      抛出：
      DateTimeException - 如果结果超出支持的日期范围

    • plusWeeks

      public OffsetDateTime  plusWeeks(long weeks)
      返回此 OffsetDateTime 的副本，其中添加了指定的周数。

      此方法将以周为单位的指定数量添加到天数字段，并根据需要递增月份和年份字段，以确保结果保持有效。仅当超过最大/最小年份时，结果才无效。

      例如，2008-12-31 加上一周将得到 2009-01-07。

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

      参数：
      weeks - 添加的周数，可能为负数
      返回：
      基于此日期时间的 OffsetDateTime 添加了周数，不为空
      抛出：
      DateTimeException - 如果结果超出支持的日期范围

    • plusDays

      public OffsetDateTime  plusDays(long days)
      返回此 OffsetDateTime 的副本，并添加了指定的天数。

      此方法将指定的金额添加到天数字段，并根据需要递增月份和年份字段，以确保结果保持有效。仅当超过最大/最小年份时，结果才无效。

      例如，2008-12-31 加上一天将得到 2009-01-01。

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

      参数：
      days - 添加的天数，可能是负数
      返回：
      基于此日期时间的 OffsetDateTime 添加天数，不为空
      抛出：
      DateTimeException - 如果结果超出支持的日期范围

    • plusHours

      public OffsetDateTime  plusHours(long hours)
      返回此 OffsetDateTime 的副本，并添加了指定的小时数。

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

      参数：
      hours - 添加的小时数，可能为负数
      返回：
      基于此日期时间的 OffsetDateTime 添加了小时数，不为空
      抛出：
      DateTimeException - 如果结果超出支持的日期范围

    • plusMinutes

      public OffsetDateTime  plusMinutes(long minutes)
      返回此 OffsetDateTime 的副本，并添加了指定的分钟数。

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

      参数：
      minutes - 添加的分钟数，可能为负数
      返回：
      基于此日期时间的 OffsetDateTime 添加了分钟，不为空
      抛出：
      DateTimeException - 如果结果超出支持的日期范围

    • plusSeconds

      public OffsetDateTime  plusSeconds(long seconds)
      返回此 OffsetDateTime 的副本，并添加了指定的秒数。

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

      参数：
      seconds - 添加的秒数，可能为负
      返回：
      基于此日期时间的 OffsetDateTime 添加了秒数，不为空
      抛出：
      DateTimeException - 如果结果超出支持的日期范围

    • plusNanos

      public OffsetDateTime  plusNanos(long nanos)
      返回此 OffsetDateTime 的副本，并添加了指定的纳秒数。

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

      参数：
      nanos - 要添加的纳米，可能为负
      返回：
      基于此日期时间的 OffsetDateTime 添加了纳秒，不为空
      抛出：
      DateTimeException - 如果无法将单位添加到此类型

    • minus

      public OffsetDateTime  minus(TemporalAmount  amountToSubtract)
      返回此日期时间的副本，并减去指定的数量。

      这将返回一个 OffsetDateTime ，基于这个，减去指定的数量。数量通常是 Period 或 Duration 但可以是实现 TemporalAmount 接口的任何其他类型。

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

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

      指定者：
      minus 在接口 Temporal 中
      参数：
      amountToSubtract - 要减去的金额，不为空
      返回：
      基于此日期时间的 OffsetDateTime 减法，不为空
      抛出：
      DateTimeException - 如果无法进行减法
      ArithmeticException - 如果发生数字溢出

    • minus

      public OffsetDateTime  minus(long amountToSubtract, TemporalUnit  unit)
      返回此日期时间的副本，并减去指定的数量。

      这将返回一个 OffsetDateTime ，基于这个，减去单位数量。如果无法减去金额，因为不支持该单位或出于其他原因，则会抛出异常。

      此方法等同于 plus(long, TemporalUnit) 取反金额。有关加法和减法如何工作的完整描述，请参阅该方法。

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

      指定者：
      minus 在接口 Temporal 中
      参数：
      amountToSubtract - 要从结果中减去的单位数量，可能为负数
      unit - 要减去的金额的单位，不为空
      返回：
      基于此日期时间的 OffsetDateTime 减去指定的金额，不为空
      抛出：
      DateTimeException - 如果无法进行减法
      UnsupportedTemporalTypeException - 如果不支持该单元
      ArithmeticException - 如果发生数字溢出

    • minusYears

      public OffsetDateTime  minusYears(long years)
      返回此 OffsetDateTime 的副本，并减去指定的年数。

      此方法分三步从年字段中减去指定的金额：

      1. 从年份字段中减去输入的年份
      2. 检查结果日期是否无效
      3. 如有必要，将日期调整为最后一个有效日期

      例如，2008-02-29（闰年）减去一年将导致无效日期 2007-02-29（标准年）。不是返回无效结果，而是选择该月的最后一个有效日期 2007-02-28。

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

      参数：
      years - 要减去的年份，可能为负数
      返回：
      基于此日期时间减去年份的 OffsetDateTime，不为空
      抛出：
      DateTimeException - 如果结果超出支持的日期范围

    • minusMonths

      public OffsetDateTime  minusMonths(long months)
      返回此 OffsetDateTime 的副本，并减去指定的月数。

      此方法分三步从月份字段中减去指定的金额：

      1. 从月份字段中减去输入的月份
      2. 检查结果日期是否无效
      3. 如有必要，将日期调整为最后一个有效日期

      例如，2007-03-31 减去一个月将导致无效日期 2007-02-31。不是返回无效结果，而是选择该月的最后一个有效日期 2007-02-28。

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

      参数：
      months - 要减去的月份，可能为负数
      返回：
      基于此日期时间的 OffsetDateTime 减去月份，不为空
      抛出：
      DateTimeException - 如果结果超出支持的日期范围

    • minusWeeks

      public OffsetDateTime  minusWeeks(long weeks)
      返回此 OffsetDateTime 的副本，并减去指定的周数。

      此方法从天字段中减去指定的周数，并根据需要递减月份和年份字段以确保结果保持有效。仅当超过最大/最小年份时，结果才无效。

      例如，2009-01-07 减去一周将得到 2008-12-31。

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

      参数：
      weeks - 要减去的周数，可能为负数
      返回：
      基于此日期时间的 OffsetDateTime 减去周数，不为空
      抛出：
      DateTimeException - 如果结果超出支持的日期范围

    • minusDays

      public OffsetDateTime  minusDays(long days)
      返回此 OffsetDateTime 的副本，并减去指定的天数。

      此方法从天字段中减去指定的金额，并根据需要递减月份和年份字段，以确保结果保持有效。仅当超过最大/最小年份时，结果才无效。

      例如，2009-01-01 减去一天将得到 2008-12-31。

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

      参数：
      days - 要减去的天数，可能为负数
      返回：
      基于此日期时间的 OffsetDateTime 减去天数，不为空
      抛出：
      DateTimeException - 如果结果超出支持的日期范围

    • minusHours

      public OffsetDateTime  minusHours(long hours)
      返回此 OffsetDateTime 的副本，并减去指定的小时数。

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

      参数：
      hours - 要减去的小时数，可能为负数
      返回：
      基于此日期时间的 OffsetDateTime 减去小时数，不为空
      抛出：
      DateTimeException - 如果结果超出支持的日期范围

    • minusMinutes

      public OffsetDateTime  minusMinutes(long minutes)
      返回此 OffsetDateTime 的副本，并减去指定的分钟数。

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

      参数：
      minutes - 要减去的分钟数，可能为负数
      返回：
      基于此日期时间的 OffsetDateTime 减去分钟数，不为空
      抛出：
      DateTimeException - 如果结果超出支持的日期范围

    • minusSeconds

      public OffsetDateTime  minusSeconds(long seconds)
      返回此 OffsetDateTime 的副本，并减去指定的秒数。

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

      参数：
      seconds - 减去的秒数，可能为负数
      返回：
      基于此日期时间的 OffsetDateTime 减去秒数，不为空
      抛出：
      DateTimeException - 如果结果超出支持的日期范围

    • minusNanos

      public OffsetDateTime  minusNanos(long nanos)
      返回此 OffsetDateTime 的副本，并减去指定的纳秒数。

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

      参数：
      nanos - 要减去的纳米，可能是负数
      返回：
      基于此日期时间的 OffsetDateTime 减去纳秒，不为空
      抛出：
      DateTimeException - 如果结果超出支持的日期范围

    • query

      public <R> R query(TemporalQuery <R> query)
      使用指定的查询查询此日期时间。

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

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

      指定者：
      query 在接口 TemporalAccessor 中
      类型参数：
      R - 结果的类型
      参数：
      query - 要调用的查询，不为空
      返回：
      查询结果，可能返回null（由查询定义）
      抛出：
      DateTimeException - 如果无法查询（由查询定义）
      ArithmeticException - 如果发生数字溢出（由查询定义）

    • adjustInto

      public Temporal  adjustInto(Temporal  temporal)
      调整指定的时间对象，使其具有与此对象相同的偏移量、日期和时间。

      这将返回一个与输入具有相同可观察类型的时间对象，偏移量、日期和时间更改为与此相同。

      调整相当于使用了三次Temporal.with(TemporalField, long) ，将ChronoField.EPOCH_DAY 、ChronoField.NANO_OF_DAY 和ChronoField.OFFSET_SECONDS 作为字段传递。

      在大多数情况下，使用 Temporal.with(TemporalAdjuster) 反转调用模式会更清楚：

        // these two lines are equivalent, but the second approach is recommended
  temporal = thisOffsetDateTime.adjustInto(temporal);
  temporal = temporal.with(thisOffsetDateTime);

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

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

    • until

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

      这根据单个 TemporalUnit 计算两个 OffsetDateTime 对象之间的时间量。起点和终点是 this 和指定的日期时间。如果结束早于开始，结果将为负。例如，可以使用 startDateTime.until(endDateTime, DAYS) 计算两个日期时间之间的天数。

      传递给此方法的 Temporal 使用 from(TemporalAccessor) 转换为 OffsetDateTime。如果两个日期时间之间的偏移量不同，则将指定的结束日期时间标准化为与该日期时间具有相同的偏移量。

      计算返回一个整数，表示两个日期时间之间的完整单位数。例如，2012-06-15T00:00Z 和 2012-08-14T23:59Z 之间的月数将只有一个月，因为两个月差一分钟。

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

        // these two lines are equivalent
  amount = start.until(end, MONTHS);
  amount = MONTHS.between(start, end);
      应该根据哪个使代码更具可读性来做出选择。

      ChronoUnit 的计算在此方法中实现。单位NANOS、MICROS、MILLIS、SECONDS、MINUTES、HOURS和HALF_DAYS、DAYS、WEEKS、MONTHS、支持YEARS、DECADES、CENTURIES、MILLENNIA和ERAS。其他 ChronoUnit 值将引发异常。

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

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

      指定者：
      until 在接口 Temporal 中
      参数：
      endExclusive - 结束日期，独占，转换为 OffsetDateTime ，不为空
      unit - 衡量数量的单位，不为空
      返回：
      此日期时间和结束日期时间之间的时间量
      抛出：
      DateTimeException - 如果无法计算数量，或者无法将结束时间转换为 OffsetDateTime
      UnsupportedTemporalTypeException - 如果不支持该单元
      ArithmeticException - 如果发生数字溢出

    • format

      public String  format(DateTimeFormatter  formatter)
      使用指定的格式化程序格式化此日期时间。

      此日期时间将传递给格式化程序以生成字符串。

      参数：
      formatter - 要使用的格式化程序，不为空
      返回：
      格式化的日期时间字符串，不为空
      抛出：
      DateTimeException - 如果在打印过程中发生错误

    • atZoneSameInstant

      public ZonedDateTime  atZoneSameInstant(ZoneId  zone)
      将此日期时间与时区组合以创建 ZonedDateTime 确保结果具有相同的时刻。

      这将返回一个 ZonedDateTime 由这个日期时间和指定的时区组成。此转换将忽略可见的本地日期时间并改用基础时刻。这避免了本地时间线间隙或重叠的任何问题。结果可能具有不同的字段值，例如小时、分钟甚至一天。

      要尝试保留字段的值，请使用 atZoneSimilarLocal(ZoneId) 。要将偏移量用作区域 ID，请使用 toZonedDateTime() 。

      参数：
      zone - 要使用的时区，不为空
      返回：
      从此日期时间形成的分区日期时间，不为空

    • atZoneSimilarLocal

      public ZonedDateTime  atZoneSimilarLocal(ZoneId  zone)
      将此日期时间与时区组合以创建一个 ZonedDateTime 试图保持相同的本地日期和时间。

      这将返回一个 ZonedDateTime 由这个日期时间和指定的时区组成。在可能的情况下，结果将具有与该对象相同的本地日期时间。

      时区规则，例如夏令时，意味着并非本地时间线上的每个时间都存在。如果本地日期时间根据规则存在间隙或重叠，则使用解析器来确定生成的本地时间和偏移量。如果可能，此方法使用 ZonedDateTime.ofLocal(LocalDateTime, ZoneId, ZoneOffset) 保留此实例的偏移量。

      可以通过两种方式更好地控制间隙和重叠。如果您只是想在重叠处使用稍后的偏移量，那么在此方法之后立即调用 ZonedDateTime.withLaterOffsetAtOverlap() 。

      要在同一时刻创建分区日期时间而不考虑本地时间线，请使用 atZoneSameInstant(ZoneId) 。要将偏移量用作区域 ID，请使用 toZonedDateTime() 。

      参数：
      zone - 要使用的时区，不为空
      返回：
      从此日期和该区域的最早有效时间形成的分区日期时间，不为空

    • toOffsetTime

      public OffsetTime  toOffsetTime()
      将此日期时间转换为 OffsetTime 。

      这将返回具有相同本地时间和偏移量的偏移时间。

      返回：
      表示时间和偏移量的 OffsetTime，不为空

    • toZonedDateTime

      public ZonedDateTime  toZonedDateTime()
      使用偏移量作为区域 ID 将此日期时间转换为 ZonedDateTime。

      这将使用偏移量作为区域 ID 创建最简单的 ZonedDateTime。

      要控制使用的时区，请参阅 atZoneSameInstant(ZoneId) 和 atZoneSimilarLocal(ZoneId) 。

      返回：
      表示相同本地日期时间和偏移量的分区日期时间，不为空

    • toInstant

      public Instant  toInstant()
      将此日期时间转换为 Instant 。

      这将返回一个 Instant 表示时间线上与此日期时间相同的点。

      返回：
      一个 Instant 表示同一时刻，不为空

    • toEpochSecond

      public long toEpochSecond()
      将此日期时间转换为从 1970-01-01T00:00:00Z 纪元算起的秒数。

      这允许将此日期时间转换为 epoch-seconds 字段的值。这主要用于低级转换而不是一般应用程序使用。

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

    • compareTo

      public int compareTo(OffsetDateTime  other)
      将此日期时间与另一个日期时间进行比较。

      比较基于本地日期时间的瞬间。正如 Comparable 所定义的那样，它“与等于一致”。

      例如，以下是比较器顺序：

      1. 2008-12-03T10:30+01:00
      2. 2008-12-03T11:00+01:00
      3. 2008-12-03T12:00+02:00
      4. 2008-12-03T11:30+01:00
      5. 2008-12-03T12:00+01:00
      6. 2008-12-03T12:30+01:00
      值 #2 和 #3 代表时间线上的同一时刻。当两个值表示同一时刻时，将比较本地日期时间以区分它们。需要此步骤才能使排序与 equals() 一致。
      指定者：
      compareTo 在接口 Comparable<OffsetDateTime> 中
      参数：
      other - 要比较的另一个日期时间，不为空
      返回：
      比较值，小于则为负，大于则为正

    • isAfter

      public boolean isAfter(OffsetDateTime  other)
      检查此日期时间的时刻是否在指定日期时间的时刻之后。

      此方法与 compareTo(java.time.OffsetDateTime) 和 equals(java.lang.Object) 中的比较不同，因为它只比较日期时间的瞬间。这相当于使用 dateTime1.toInstant().isAfter(dateTime2.toInstant()); 。

      参数：
      other - 要比较的另一个日期时间，不为空
      返回：
      如果这是在指定日期时间的瞬间之后，则为真

    • isBefore

      public boolean isBefore(OffsetDateTime  other)
      检查此日期时间的时刻是否早于指定日期时间的时刻。

      此方法与 compareTo(java.time.OffsetDateTime) 中的比较不同，因为它只比较日期时间的瞬间。这相当于使用 dateTime1.toInstant().isBefore(dateTime2.toInstant()); 。

      参数：
      other - 要比较的另一个日期时间，不为空
      返回：
      如果这是在指定日期时间之前，则为真

    • isEqual

      public boolean isEqual(OffsetDateTime  other)
      检查此日期时间的时刻是否等于指定日期时间的时刻。

      此方法与 compareTo(java.time.OffsetDateTime) 和 equals(java.lang.Object) 中的比较不同，因为它只比较日期时间的瞬间。这相当于使用 dateTime1.toInstant().equals(dateTime2.toInstant()); 。

      参数：
      other - 要比较的另一个日期时间，不为空
      返回：
      如果瞬间等于指定日期时间的瞬间，则为真

    • equals

      public boolean equals(Object  obj)
      检查此日期时间是否等于另一个日期时间。

      比较基于本地日期时间和偏移量。要比较时间线上的同一时刻，请使用 isEqual(java.time.OffsetDateTime) 。只比较 OffsetDateTime 类型的对象，其他类型返回 false。

      重写：
      equals 在类 Object 中
      参数：
      obj - 要检查的对象，null 返回 false
      返回：
      如果这等于另一个日期时间，则为真
      参见：

    • hashCode

      public int hashCode()
      此日期时间的哈希码。
      重写：
      hashCode 在类 Object 中
      返回：
      合适的哈希码
      参见：

    • toString

      public String  toString()
      将此日期时间输出为 String ，例如 2007-12-03T10:15:30+01:00 。

      输出将是以下格式之一：

      • uuuu-MM-dd'T'HH:mmXXXXX
      • uuuu-MM-dd'T'HH:mm:ssXXXXX
      • uuuu-MM-dd'T'HH:mm:ss.SSSXXXXX
      • uuuu-MM-dd'T'HH:mm:ss.SSSSSSXXXXX
      • uuuu-MM-dd'T'HH:mm:ss.SSSSSSSSSXXXXX
      使用的格式将是输出时间的完整值的最短格式，其中省略的部分隐含为零。如果偏移量中的秒数为零，则输出与 ISO 8601 兼容。
      重写：
      toString 在类 Object 中
      返回：
      此日期时间的字符串表示形式，不为空