模块 java.base
包 java.time

类 ZonedDateTime

java.lang.Object
java.time.ZonedDateTime
所有已实现的接口：
Serializable , Comparable<ChronoZonedDateTime<?>> , ChronoZonedDateTime<LocalDate> , Temporal , TemporalAccessor
public final class ZonedDateTime extends Object implements Temporal , ChronoZonedDateTime <LocalDate >, Serializable
ISO-8601 日历系统中带有时区的日期时间，例如 2007-12-03T10:15:30+01:00 Europe/Paris 。

ZonedDateTime 是带有时区的日期时间的不可变表示。此类存储所有日期和时间字段（精度为纳秒）和时区，以及用于处理不明确的本地日期时间的时区偏移量。例如，值“欧洲/巴黎时区 2007 年 10 月 2 日 13:45.30.123456789 +02:00”可以存储在 ZonedDateTime 中。

此类处理从 LocalDateTime 的本地时间线到 Instant 的即时时间线的转换。两条时间线之间的差异是与 UTC/格林威治的偏移量，由 ZoneOffset 表示。

两条时间线之间的转换涉及使用从 ZoneId 访问的 rules 计算偏移量。获得瞬间的偏移量很简单，因为每个瞬间只有一个有效偏移量。相比之下，获取本地日期时间的偏移量并不简单。有以下三种情况：

  • 正常，具有一个有效偏移量。对于一年中的绝大多数时间，正常情况适用，本地日期时间有一个有效的偏移量。
  • 间隙，有效偏移量为零。这通常是由于春季夏令时从“冬季”变为“夏季”而导致时钟向前跳动的时候。在间隙中，存在没有有效偏移量的本地日期时间值。
  • 重叠，具有两个有效偏移量。这是通常由于秋季夏令时从“夏季”变为“冬季”而导致时钟拨回的时间。在重叠中，存在具有两个有效偏移量的本地日期时间值。

任何通过获取偏移量直接或隐式地将本地日期时间转换为瞬间的方法都有可能变得复杂。

对于 Gaps，一般策略是，如果本地日期时间落在 Gap 的中间，那么生成的分区日期时间会将本地日期时间向前移动 Gap 的长度，从而产生日期 -稍后偏移量中的时间，通常是“夏季”时间。

对于 Overlaps，一般策略是如果本地日期时间落在 Overlap 的中间，那么之前的偏移量将被保留。如果没有先前的偏移量，或者先前的偏移量无效，则使用较早的偏移量，通常是“夏季”时间。另外两种方法 withEarlierOffsetAtOverlap() 和 withLaterOffsetAtOverlap() 有助于管理重叠的情况。

在设计方面，此类应主要视为 LocalDateTime 和 ZoneId 的组合。 ZoneOffset 是一条重要但次要的信息，用于确保该类代表一个瞬间，尤其是在夏令时重叠期间。

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

实现要求：
ZonedDateTime 持有等同于三个独立对象的状态，a LocalDateTime，a ZoneId 和已解析的 ZoneOffset。偏移量和本地日期时间用于在必要时定义一个瞬间。区域 ID 用于获取偏移量如何以及何时更改的规则。不能自由设置偏移量，因为区域控制哪些偏移量有效。

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

自从：
1.8
参见：

  • 方法详情

    • now

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

      这将查询默认时区中的 system clock 以获取当前日期时间。区域和偏移量将根据时钟中的时区设置。

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

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

    • now

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

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

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

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

    • now

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

      这将查询指定的时钟以获取当前日期时间。区域和偏移量将根据时钟中的时区设置。

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

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

    • of

      public static ZonedDateTime  of(LocalDate  date, LocalTime  time, ZoneId  zone)
      从本地日期和时间获取 ZonedDateTime 的实例。

      这将创建一个与输入的本地日期和时间尽可能匹配的分区日期时间。时区规则，例如夏令时，意味着并非每个本地日期时间都对指定区域有效，因此可以调整本地日期时间。

      本地日期时间和第一个组合形成本地日期时间。然后将本地日期时间解析为时间线上的单个瞬间。这是通过为由区域 ID 的 rules 定义的本地日期时间找到与 UTC/格林威治的有效偏移量来实现的。

      在大多数情况下，本地日期时间只有一个有效偏移量。在重叠的情况下，当时钟向后设置时，有两个有效偏移量。此方法使用通常对应于“夏季”的较早偏移量。

      在间隙的情况下，当时钟向前跳跃时，没有有效的偏移量。相反，本地日期时间被调整为较晚的间隔长度。对于典型的一小时夏令时更改，本地日期时间将在一小时后移动到通常对应于“夏季”的偏移量中。

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

    • of

      public static ZonedDateTime  of(LocalDateTime  localDateTime, ZoneId  zone)
      从本地日期时间获取 ZonedDateTime 的实例。

      这将创建一个与输入的本地日期时间尽可能匹配的分区日期时间。时区规则，例如夏令时，意味着并非每个本地日期时间都对指定区域有效，因此可以调整本地日期时间。

      本地日期时间被解析为时间线上的单个瞬间。这是通过为由区域 ID 的 rules 定义的本地日期时间找到与 UTC/格林威治的有效偏移量来实现的。

      在大多数情况下，本地日期时间只有一个有效偏移量。在重叠的情况下，当时钟向后设置时，有两个有效偏移量。此方法使用通常对应于“夏季”的较早偏移量。

      在间隙的情况下，当时钟向前跳跃时，没有有效的偏移量。相反，本地日期时间被调整为较晚的间隔长度。对于典型的一小时夏令时更改，本地日期时间将在一小时后移动到通常对应于“夏季”的偏移量中。

      参数：
      localDateTime - 本地日期时间，不为空
      zone - 时区，不为空
      返回：
      分区日期时间，不为空

    • of

      public static ZonedDateTime  of(int year, int month, int dayOfMonth, int hour, int minute, int second, int nanoOfSecond, ZoneId  zone)
      从年、月、日、小时、分钟、秒、纳秒和时区获取 ZonedDateTime 的实例。

      这将创建一个尽可能接近地匹配七个指定字段的本地日期时间的分区日期时间。时区规则，例如夏令时，意味着并非每个本地日期时间都对指定区域有效，因此可以调整本地日期时间。

      本地日期时间被解析为时间线上的单个瞬间。这是通过为由区域 ID 的 rules 定义的本地日期时间找到与 UTC/格林威治的有效偏移量来实现的。

      在大多数情况下，本地日期时间只有一个有效偏移量。在重叠的情况下，当时钟向后设置时，有两个有效偏移量。此方法使用通常对应于“夏季”的较早偏移量。

      在间隙的情况下，当时钟向前跳跃时，没有有效的偏移量。相反，本地日期时间被调整为较晚的间隔长度。对于典型的一小时夏令时更改，本地日期时间将在一小时后移动到通常对应于“夏季”的偏移量中。

      此方法主要用于编写测试用例。非测试代码通常会使用其他方法来创建偏移时间。 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
      zone - 时区，不为空
      返回：
      偏移日期时间，不为空
      抛出：
      DateTimeException - 如果任何字段的值超出范围，或者如果月份日期对于月份年份无效

    • ofLocal

      public static ZonedDateTime  ofLocal(LocalDateTime  localDateTime, ZoneId  zone, ZoneOffset  preferredOffset)
      如果可能，使用首选偏移量从本地日期时间获取 ZonedDateTime 的实例。

      本地日期时间被解析为时间线上的单个瞬间。这是通过为由区域 ID 的 rules 定义的本地日期时间找到与 UTC/格林威治的有效偏移量来实现的。

      在大多数情况下，本地日期时间只有一个有效偏移量。在重叠的情况下，时钟向后设置，有两个有效的偏移量。如果首选偏移量是有效偏移量之一，则使用它。否则使用较早的有效偏移量，通常对应于“夏季”。

      在间隙的情况下，时钟向前跳跃，没有有效的偏移量。相反，本地日期时间被调整为较晚的间隔长度。对于典型的一小时夏令时更改，本地日期时间将在一小时后移动到通常对应于“夏季”的偏移量中。

      参数：
      localDateTime - 本地日期时间，不为空
      zone - 时区，不为空
      preferredOffset - 区域偏移量，如果没有偏好则为 null
      返回：
      分区日期时间，不为空

    • ofInstant

      public static ZonedDateTime  ofInstant(Instant  instant, ZoneId  zone)
      从 Instant 获得 ZonedDateTime 的实例。

      这将创建一个与指定时刻具有相同时刻的分区日期时间。调用 ChronoZonedDateTime.toInstant() 将返回等于此处使用的瞬间。

      将瞬间转换为分区日期时间很简单，因为每个瞬间只有一个有效偏移量。

      参数：
      instant - 创建日期时间的时刻，不为空
      zone - 时区，不为空
      返回：
      分区日期时间，不为空
      抛出：
      DateTimeException - 如果结果超出支持的范围

    • ofInstant

      public static ZonedDateTime  ofInstant(LocalDateTime  localDateTime, ZoneOffset  offset, ZoneId  zone)
      从结合本地日期时间和偏移量形成的瞬间获得 ZonedDateTime 的实例。

      这会根据 combining LocalDateTime 和 ZoneOffset 创建分区日期时间。这种组合唯一地指定了一个瞬间而没有歧义。

      将瞬间转换为分区日期时间很简单，因为每个瞬间只有一个有效偏移量。如果有效偏移量与指定的偏移量不同，则分区日期时间的日期时间和偏移量将与指定的不同。

      如果要使用的 ZoneId 是 ZoneOffset ，则此方法等效于 of(LocalDateTime, ZoneId) 。

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

    • ofStrict

      public static ZonedDateTime  ofStrict(LocalDateTime  localDateTime, ZoneOffset  offset, ZoneId  zone)
      获取 ZonedDateTime 的实例，严格验证本地日期时间、偏移量和区域 ID 的组合。

      这将创建一个分区日期时间，确保偏移量根据指定区域的规则对本地日期时间有效。如果偏移量无效，则抛出异常。

      参数：
      localDateTime - 本地日期时间，不为空
      offset - 区域偏移量，不为空
      zone - 时区，不为空
      返回：
      分区日期时间，不为空
      抛出：
      DateTimeException - 如果参数组合无效

    • from

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

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

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

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

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

    • parse

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

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

      参数：
      text - 要解析的文本，例如“2007-12-03T10:15:30+01:00[欧洲/巴黎]”，不为空
      返回：
      解析的分区日期时间，不为空
      抛出：
      DateTimeParseException - 如果无法解析文本

    • parse

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

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

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

    • getOffset

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

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

      指定者：
      getOffset 在接口 ChronoZonedDateTime<LocalDate> 中
      返回：
      区域偏移量，不为空

    • withEarlierOffsetAtOverlap

      public ZonedDateTime  withEarlierOffsetAtOverlap()
      返回此日期时间的副本，将区域偏移量更改为本地时间线重叠处两个有效偏移量中较早的一个。

      此方法仅在本地时间线重叠时有效，例如在秋季夏令时切换时。在这种情况下，本地日期时间有两个有效偏移量。调用此方法将返回一个分区日期时间，其中选择了两个中较早的一个。

      如果在不重叠时调用此方法，则返回this。

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

      指定者：
      withEarlierOffsetAtOverlap 在接口 ChronoZonedDateTime<LocalDate> 中
      返回：
      a ZonedDateTime 基于此日期时间，具有较早的偏移量，不为空

    • withLaterOffsetAtOverlap

      public ZonedDateTime  withLaterOffsetAtOverlap()
      返回此日期时间的副本，将区域偏移量更改为本地时间线重叠处两个有效偏移量中较晚的一个。

      此方法仅在本地时间线重叠时有效，例如在秋季夏令时切换时。在这种情况下，本地日期时间有两个有效偏移量。调用此方法将返回一个分区日期时间，其中选择了两者中的较晚者。

      如果在不重叠时调用此方法，则返回this。

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

      指定者：
      withLaterOffsetAtOverlap 在接口 ChronoZonedDateTime<LocalDate> 中
      返回：
      ZonedDateTime 基于此日期时间，具有较晚的偏移量，不为空

    • getZone

      public ZoneId  getZone()
      获取时区，例如“欧洲/巴黎”。

      这将返回区域 ID。这标识了时区 rules ，它确定与 UTC/格林威治的偏移量何时以及如何变化。

      区域 ID 可能与 offset 相同。如果这是真的，那么任何未来的计算，例如加法或减法，都不会因为时区规则而出现复杂的边缘情况。另请参阅 withFixedOffsetZone() 。

      指定者：
      getZone 在接口 ChronoZonedDateTime<LocalDate> 中
      返回：
      时区，不为空

    • withZoneSameLocal

      public ZonedDateTime  withZoneSameLocal(ZoneId  zone)
      返回具有不同时区的此日期时间的副本，如果可能，保留本地日期时间。

      此方法更改时区并保留本地日期时间。仅当本地日期时间对新区域无效时才会更改，使用与 ofLocal(LocalDateTime, ZoneId, ZoneOffset) 相同的方法确定。

      要更改区域并调整本地日期时间，请使用 withZoneSameInstant(ZoneId) 。

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

      指定者：
      withZoneSameLocal 在接口 ChronoZonedDateTime<LocalDate> 中
      参数：
      zone - 要更改为的时区，不为空
      返回：
      ZonedDateTime 基于此日期时间和请求的区域，不为空

    • withZoneSameInstant

      public ZonedDateTime  withZoneSameInstant(ZoneId  zone)
      返回具有不同时区的此日期时间的副本，保留瞬间。

      此方法更改时区并保留时间。这通常会导致更改本地日期时间。

      此方法基于保留同一时刻，因此本地时间线中的间隙和重叠对结果没有影响。

      要在保持本地时间的同时更改偏移量，请使用 withZoneSameLocal(ZoneId) 。

      指定者：
      withZoneSameInstant 在接口 ChronoZonedDateTime<LocalDate> 中
      参数：
      zone - 要更改为的时区，不为空
      返回：
      ZonedDateTime 基于此日期时间和请求的区域，不为空
      抛出：
      DateTimeException - 如果结果超出支持的日期范围

    • withFixedOffsetZone

      public ZonedDateTime  withFixedOffsetZone()
      返回此日期时间的副本，并将区域 ID 设置为偏移量。

      这将返回一个分区日期时间，其中区域 ID 与 getOffset() 相同。结果的本地日期时间、偏移量和瞬间将与此日期时间中的相同。

      将日期时间设置为固定的单个偏移量意味着任何未来的计算（例如加法或减法）都不会因时区规则而出现复杂的边缘情况。这在通过网络发送分区日期时间时也可能很有用，因为大多数协议（例如 ISO-8601）仅处理偏移量，而不处理基于区域的区域 ID。

      这相当于 ZonedDateTime.of(zdt.toLocalDateTime(), zdt.getOffset()) 。

      返回：
      一个 ZonedDateTime，区域 ID 设置为偏移量，不为空

    • toLocalDateTime

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

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

      指定者：
      toLocalDateTime 在接口 ChronoZonedDateTime<LocalDate> 中
      返回：
      此日期时间的本地日期时间部分，不为空

    • toLocalDate

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

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

      指定者：
      toLocalDate 在接口 ChronoZonedDateTime<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 与此日期时间具有相同的小时、分钟、秒和纳秒。

      指定者：
      toLocalTime 在接口 ChronoZonedDateTime<LocalDate> 中
      返回：
      此日期时间的时间部分，不为空

    • 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 ZonedDateTime  with(TemporalAdjuster  adjuster)
      返回此日期时间的调整副本。

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

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

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

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

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

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

       result = zonedDateTime.with(date);
 result = zonedDateTime.with(time);

      ZoneOffset 也实现了 TemporalAdjuster 但是将它用作参数通常没有效果。 ZonedDateTime 的偏移量主要由时区控制。因此，更改偏移量通常没有意义，因为本地日期时间和时区只有一个有效偏移量。如果分区日期时间处于夏令时重叠，则偏移量用于在两个有效偏移量之间切换。在所有其他情况下，偏移量将被忽略。

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

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

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

    • with

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

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

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

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

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

      OFFSET_SECONDS 字段通常会被忽略。 ZonedDateTime 的偏移量主要由时区控制。因此，更改偏移量通常没有意义，因为本地日期时间和时区只有一个有效偏移量。如果分区日期时间处于夏令时重叠，则偏移量用于在两个有效偏移量之间切换。在所有其他情况下，偏移量将被忽略。如果新的偏移值超出有效范围，则会抛出 DateTimeException。

      另一个 supported fields 将按照 LocalDateTime 上的匹配方法运行。该区域不是计算的一部分，将保持不变。转换回 ZonedDateTime 时，如果本地日期时间重叠，则尽可能保留偏移量，否则将使用较早的偏移量。如果在间隙中，本地日期时间将向前调整间隙的长度。

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

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

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

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

    • withYear

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

      这在本地时间线上运行，本地日期时间的changing the year 。然后将其转换回 ZonedDateTime ，使用区域 ID 获取偏移量。

      转换回 ZonedDateTime 时，如果本地日期时间重叠，则尽可能保留偏移量，否则将使用较早的偏移量。如果在间隙中，本地日期时间将向前调整间隙的长度。

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

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

    • withMonth

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

      这在本地时间线上运行，本地日期时间的changing the month 。然后将其转换回 ZonedDateTime ，使用区域 ID 获取偏移量。

      转换回 ZonedDateTime 时，如果本地日期时间重叠，则尽可能保留偏移量，否则将使用较早的偏移量。如果在间隙中，本地日期时间将向前调整间隙的长度。

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

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

    • withDayOfMonth

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

      这在本地时间线上运行，本地日期时间的changing the day-of-month 。然后将其转换回 ZonedDateTime ，使用区域 ID 获取偏移量。

      转换回 ZonedDateTime 时，如果本地日期时间重叠，则尽可能保留偏移量，否则将使用较早的偏移量。如果在间隙中，本地日期时间将向前调整间隙的长度。

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

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

    • withDayOfYear

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

      这在本地时间线上运行，本地日期时间的changing the day-of-year 。然后将其转换回 ZonedDateTime ，使用区域 ID 获取偏移量。

      转换回 ZonedDateTime 时，如果本地日期时间重叠，则尽可能保留偏移量，否则将使用较早的偏移量。如果在间隙中，本地日期时间将向前调整间隙的长度。

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

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

    • withHour

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

      这在本地时间线上运行，本地日期时间的改变时间。然后将其转换回 ZonedDateTime ，使用区域 ID 获取偏移量。

      转换回 ZonedDateTime 时，如果本地日期时间重叠，则尽可能保留偏移量，否则将使用较早的偏移量。如果在间隙中，本地日期时间将向前调整间隙的长度。

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

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

    • withMinute

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

      这在本地时间线上运行，本地日期时间的改变时间。然后将其转换回 ZonedDateTime ，使用区域 ID 获取偏移量。

      转换回 ZonedDateTime 时，如果本地日期时间重叠，则尽可能保留偏移量，否则将使用较早的偏移量。如果在间隙中，本地日期时间将向前调整间隙的长度。

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

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

    • withSecond

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

      这在本地时间线上运行，本地日期时间的改变时间。然后将其转换回 ZonedDateTime ，使用区域 ID 获取偏移量。

      转换回 ZonedDateTime 时，如果本地日期时间重叠，则尽可能保留偏移量，否则将使用较早的偏移量。如果在间隙中，本地日期时间将向前调整间隙的长度。

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

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

    • withNano

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

      这在本地时间线上运行，本地日期时间的改变时间。然后将其转换回 ZonedDateTime ，使用区域 ID 获取偏移量。

      转换回 ZonedDateTime 时，如果本地日期时间重叠，则尽可能保留偏移量，否则将使用较早的偏移量。如果在间隙中，本地日期时间将向前调整间隙的长度。

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

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

    • truncatedTo

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

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

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

      这在本地时间线上运行，truncating 底层本地日期时间。然后将其转换回 ZonedDateTime ，使用区域 ID 获取偏移量。

      转换回 ZonedDateTime 时，如果本地日期时间重叠，则尽可能保留偏移量，否则将使用较早的偏移量。如果在间隙中，本地日期时间将向前调整间隙的长度。

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

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

    • plus

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

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

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

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

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

    • plus

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

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

      如果该字段是ChronoUnit ，则在此处实现加法。该区域不是计算的一部分，结果将保持不变。日期和时间单位的计算不同。

      日期单位在本地时间线上运行。该时间段首先添加到本地日期时间，然后使用区域 ID 转换回分区日期时间。转换使用 ofLocal(LocalDateTime, ZoneId, ZoneOffset) 和加法前的偏移量。

      时间单位在即时时间线上运行。该时间段首先添加到本地日期时间，然后使用区域 ID 转换回分区日期时间。转换使用 ofInstant(LocalDateTime, ZoneOffset, ZoneId) 和加法前的偏移量。

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

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

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

    • plusYears

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

      这在本地时间线上运行，adding years 到本地日期时间。然后将其转换回 ZonedDateTime ，使用区域 ID 获取偏移量。

      转换回 ZonedDateTime 时，如果本地日期时间重叠，则尽可能保留偏移量，否则将使用较早的偏移量。如果在间隙中，本地日期时间将向前调整间隙的长度。

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

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

    • plusMonths

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

      这在本地时间线上运行，adding months 到本地日期时间。然后将其转换回 ZonedDateTime ，使用区域 ID 获取偏移量。

      转换回 ZonedDateTime 时，如果本地日期时间重叠，则尽可能保留偏移量，否则将使用较早的偏移量。如果在间隙中，本地日期时间将向前调整间隙的长度。

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

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

    • plusWeeks

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

      这在本地时间线上运行，adding weeks 到本地日期时间。然后将其转换回 ZonedDateTime ，使用区域 ID 获取偏移量。

      转换回 ZonedDateTime 时，如果本地日期时间重叠，则尽可能保留偏移量，否则将使用较早的偏移量。如果在间隙中，本地日期时间将向前调整间隙的长度。

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

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

    • plusDays

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

      这在本地时间线上运行，adding days 到本地日期时间。然后将其转换回 ZonedDateTime ，使用区域 ID 获取偏移量。

      转换回 ZonedDateTime 时，如果本地日期时间重叠，则尽可能保留偏移量，否则将使用较早的偏移量。如果在间隙中，本地日期时间将向前调整间隙的长度。

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

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

    • plusHours

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

      这在即时时间线上运行，因此添加一小时将始终是一小时后的持续时间。这可能会导致本地日期时间发生一小时以外的变化。请注意，这与按天、月和年使用的方法不同，因此添加一天与添加 24 小时不同。

      例如，考虑一个时区，例如“欧洲/巴黎”，其中秋季夏令时转换意味着当地时间 02:00 到 02:59 出现两次，从夏季的偏移量 +02:00 变为 +01:00冬天里。

      • 将 01:30+02:00 加一小时将得到 02:30+02:00（均为夏令时）
      • 将 02:30+02:00 加一小时将得到 02:30+01:00（从夏令时移至冬令时）
      • 将 02:30+01:00 添加一小时将导致 03:30+01:00（均为冬令时）
      • 将 01:30+02:00 添加三个小时将导致 03:30+01:00（从夏令时移至冬令时）

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

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

    • plusMinutes

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

      这在即时时间线上运行，因此添加一分钟将始终是一分钟后的持续时间。这可能会导致本地日期时间发生一分钟以外的变化。请注意，这与按天、月和年使用的方法不同。

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

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

    • plusSeconds

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

      这在即时时间线上运行，因此添加一秒将始终是一秒后的持续时间。这可能会导致本地日期时间发生一秒以外的变化。请注意，这与按天、月和年使用的方法不同。

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

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

    • plusNanos

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

      这是在即时时间线上运行的，这样一来，添加一纳秒将始终是一纳秒后的持续时间。这可能会导致本地日期时间的变化量超过一纳秒。请注意，这与按天、月和年使用的方法不同。

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

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

    • minus

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

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

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

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

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

    • minus

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

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

      日期和时间单位的计算不同。

      日期单位在本地时间线上运行。该时间段首先从本地日期时间中减去，然后使用区域 ID 转换回分区日期时间。转换使用 ofLocal(LocalDateTime, ZoneId, ZoneOffset) 和减法前的偏移量。

      时间单位在即时时间线上运行。该时间段首先从本地日期时间中减去，然后使用区域 ID 转换回分区日期时间。转换使用 ofInstant(LocalDateTime, ZoneOffset, ZoneId) 和减法前的偏移量。

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

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

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

    • minusYears

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

      这在本地时间线上运行，subtracting years 到本地日期时间。然后将其转换回 ZonedDateTime ，使用区域 ID 获取偏移量。

      转换回 ZonedDateTime 时，如果本地日期时间重叠，则尽可能保留偏移量，否则将使用较早的偏移量。如果在间隙中，本地日期时间将向前调整间隙的长度。

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

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

    • minusMonths

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

      这在本地时间线上运行，subtracting months 到本地日期时间。然后将其转换回 ZonedDateTime ，使用区域 ID 获取偏移量。

      转换回 ZonedDateTime 时，如果本地日期时间重叠，则尽可能保留偏移量，否则将使用较早的偏移量。如果在间隙中，本地日期时间将向前调整间隙的长度。

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

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

    • minusWeeks

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

      这在本地时间线上运行，subtracting weeks 到本地日期时间。然后将其转换回 ZonedDateTime ，使用区域 ID 获取偏移量。

      转换回 ZonedDateTime 时，如果本地日期时间重叠，则尽可能保留偏移量，否则将使用较早的偏移量。如果在间隙中，本地日期时间将向前调整间隙的长度。

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

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

    • minusDays

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

      这在本地时间线上运行，subtracting days 到本地日期时间。然后将其转换回 ZonedDateTime ，使用区域 ID 获取偏移量。

      转换回 ZonedDateTime 时，如果本地日期时间重叠，则尽可能保留偏移量，否则将使用较早的偏移量。如果在间隙中，本地日期时间将向前调整间隙的长度。

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

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

    • minusHours

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

      这在即时时间线上运行，因此减去一小时将始终是提前一小时的持续时间。这可能会导致本地日期时间发生一小时以外的变化。请注意，这与按天、月和年使用的方法不同，因此减去一天与增加 24 小时不同。

      例如，考虑一个时区，例如“欧洲/巴黎”，其中秋季夏令时转换意味着当地时间 02:00 到 02:59 出现两次，从夏季的偏移量 +02:00 变为 +01:00冬天里。

      • 从 03:30+01:00 减去一小时将得到 02:30+01:00（均为冬令时）
      • 从 02:30+01:00 减去一小时将得到 02:30+02:00（从冬令时移至夏令时）
      • 从 02:30+02:00 减去一小时将得到 01:30+02:00（均为夏令时）
      • 从 03:30+01:00 减去三个小时将得到 01:30+02:00（从冬令时移至夏令时）

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

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

    • minusMinutes

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

      这在即时时间线上运行，因此减去一分钟将始终是前一分钟的持续时间。这可能会导致本地日期时间发生一分钟以外的变化。请注意，这与按天、月和年使用的方法不同。

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

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

    • minusSeconds

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

      这在即时时间线上运行，因此减去一秒将始终是前一秒的持续时间。这可能会导致本地日期时间发生一秒以外的变化。请注意，这与按天、月和年使用的方法不同。

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

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

    • minusNanos

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

      这在即时时间线上运行，因此减去一纳秒总是会提前一纳秒的持续时间。这可能会导致本地日期时间的变化量超过一纳秒。请注意，这与按天、月和年使用的方法不同。

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

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

    • query

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

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

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

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

    • until

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

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

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

      计算返回一个整数，表示两个日期时间之间的完整单位数。例如，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 值将引发异常。

      日期和时间单位的计算不同。

      日期单位在本地时间线上运行，使用本地日期时间。例如，从第 1 天中午到第二天中午的天数将始终正好计算为一天，无论是否存在夏令时更改。

      时间单位在即时时间线上运行。该计算有效地将两个分区日期时间转换为瞬间，然后计算瞬间之间的时间段。例如，从第一天中午到第二天中午的时间段可能是 23、24 或 25 小时（或其他时间），具体取决于是否存在夏令时变化。

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

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

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

    • format

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

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

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

    • toOffsetDateTime

      public OffsetDateTime  toOffsetDateTime()
      将此日期时间转换为 OffsetDateTime 。

      这将使用本地日期时间和偏移量创建偏移日期时间。区域 ID 将被忽略。

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

    • equals

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

      比较基于偏移日期时间和区域。只比较 ZonedDateTime 类型的对象，其他类型返回 false。

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

    • hashCode

      public int hashCode()
      此日期时间的哈希码。
      指定者：
      hashCode 在接口 ChronoZonedDateTime<LocalDate> 中
      重写：
      hashCode 在类 Object 中
      返回：
      合适的哈希码
      参见：

    • toString

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

      该格式由 LocalDateTime 后跟 ZoneOffset 组成。如果 ZoneId 与偏移量不同，则输出 ID。如果偏移量和 ID 相同，则输出与 ISO-8601 兼容。

      指定者：
      toString 在接口 ChronoZonedDateTime<LocalDate> 中
      重写：
      toString 在类 Object 中
      返回：
      此日期时间的字符串表示形式，不为空