Module java.base
Package java.time

Class 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/Greenwich的偏移量，由ZoneOffset表示。

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

  • 正常，有一个有效的偏移量。在大多数时间里，正常情况适用，本地日期时间有一个单一有效的偏移量。
  • 间隙，没有有效的偏移量。这是时钟向前跳跃的情况，通常是由于从“冬季”到“夏季”的春季节约时间变更。在间隙中，存在没有有效偏移量的本地日期时间值。
  • 重叠，有两个有效的偏移量。这是时钟向后设置的情况，通常是由于从“夏季”到“冬季”的秋季节约时间变更。在重叠中，存在两个有效偏移量的本地日期时间值。

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

对于间隙，一般策略是，如果本地日期时间落在间隙中间，则结果的分区日期时间将向前移动间隙的长度，导致一个处于后续偏移量的日期时间，通常是“夏季”时间。

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

在设计方面，这个类应该主要被视为LocalDateTime和ZoneId的组合。ZoneOffset是一个重要但次要的信息，用于确保该类表示一个即时时间，特别是在夏令时重叠期间。

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

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

该类是不可变的且线程安全的。

自Java版本:
1.8
参见:

  • Method Details

    • now

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

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

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

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

    • now

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

      这将查询系统时钟以获取当前日期时间。指定时区可避免依赖默认时区。偏移将根据指定时区计算。

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

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

    • now

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

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

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

      参数:
      clock - 要使用的时钟，不为null
      返回:
      当前日期时间，不为null

    • of

      public static ZonedDateTime of(LocalDate date, LocalTime time, ZoneId zone)
      Obtains an instance of ZonedDateTime from a local date and time.

      This creates a zoned date-time matching the input local date and time as closely as possible. Time-zone rules, such as daylight savings, mean that not every local date-time is valid for the specified zone, thus the local date-time may be adjusted.

      The local date time and first combined to form a local date-time. The local date-time is then resolved to a single instant on the time-line. This is achieved by finding a valid offset from UTC/Greenwich for the local date-time as defined by the rules of the zone ID.

      In most cases, there is only one valid offset for a local date-time. In the case of an overlap, when clocks are set back, there are two valid offsets. This method uses the earlier offset typically corresponding to "summer".

      In the case of a gap, when clocks jump forward, there is no valid offset. Instead, the local date-time is adjusted to be later by the length of the gap. For a typical one hour daylight savings change, the local date-time will be moved one hour later into the offset typically corresponding to "summer".

      Parameters:
      date - the local date, not null
      time - the local time, not null
      zone - the time-zone, not null
      Returns:
      the offset date-time, not null

    • of

      public static ZonedDateTime of(LocalDateTime localDateTime, ZoneId zone)
      Obtains an instance of ZonedDateTime from a local date-time.

      This creates a zoned date-time matching the input local date-time as closely as possible. Time-zone rules, such as daylight savings, mean that not every local date-time is valid for the specified zone, thus the local date-time may be adjusted.

      The local date-time is resolved to a single instant on the time-line. This is achieved by finding a valid offset from UTC/Greenwich for the local date-time as defined by the rules of the zone ID.

      In most cases, there is only one valid offset for a local date-time. In the case of an overlap, when clocks are set back, there are two valid offsets. This method uses the earlier offset typically corresponding to "summer".

      In the case of a gap, when clocks jump forward, there is no valid offset. Instead, the local date-time is adjusted to be later by the length of the gap. For a typical one hour daylight savings change, the local date-time will be moved one hour later into the offset typically corresponding to "summer".

      Parameters:
      localDateTime - the local date-time, not null
      zone - the time-zone, not null
      Returns:
      the zoned date-time, not null

    • of

      public static ZonedDateTime of(int year, int month, int dayOfMonth, int hour, int minute, int second, int nanoOfSecond, ZoneId zone)
      Obtains an instance of ZonedDateTime from a year, month, day, hour, minute, second, nanosecond and time-zone.

      This creates a zoned date-time matching the local date-time of the seven specified fields as closely as possible. Time-zone rules, such as daylight savings, mean that not every local date-time is valid for the specified zone, thus the local date-time may be adjusted.

      The local date-time is resolved to a single instant on the time-line. This is achieved by finding a valid offset from UTC/Greenwich for the local date-time as defined by the rules of the zone ID.

      In most cases, there is only one valid offset for a local date-time. In the case of an overlap, when clocks are set back, there are two valid offsets. This method uses the earlier offset typically corresponding to "summer".

      In the case of a gap, when clocks jump forward, there is no valid offset. Instead, the local date-time is adjusted to be later by the length of the gap. For a typical one hour daylight savings change, the local date-time will be moved one hour later into the offset typically corresponding to "summer".

      This method exists primarily for writing test cases. Non test-code will typically use other methods to create an offset time. LocalDateTime has five additional convenience variants of the equivalent factory method taking fewer arguments. They are not provided here to reduce the footprint of the API.

      Parameters:
      year - the year to represent, from MIN_YEAR to MAX_YEAR
      month - the month-of-year to represent, from 1 (January) to 12 (December)
      dayOfMonth - the day-of-month to represent, from 1 to 31
      hour - the hour-of-day to represent, from 0 to 23
      minute - the minute-of-hour to represent, from 0 to 59
      second - the second-of-minute to represent, from 0 to 59
      nanoOfSecond - the nano-of-second to represent, from 0 to 999,999,999
      zone - the time-zone, not null
      Returns:
      the offset date-time, not null
      Throws:
      DateTimeException - if the value of any field is out of range, or if the day-of-month is invalid for the month-year

    • ofLocal

      public static ZonedDateTime ofLocal(LocalDateTime localDateTime, ZoneId zone, ZoneOffset preferredOffset)
      Obtains an instance of ZonedDateTime from a local date-time using the preferred offset if possible.

      The local date-time is resolved to a single instant on the time-line. This is achieved by finding a valid offset from UTC/Greenwich for the local date-time as defined by the rules of the zone ID.

      In most cases, there is only one valid offset for a local date-time. In the case of an overlap, where clocks are set back, there are two valid offsets. If the preferred offset is one of the valid offsets then it is used. Otherwise the earlier valid offset is used, typically corresponding to "summer".

      In the case of a gap, where clocks jump forward, there is no valid offset. Instead, the local date-time is adjusted to be later by the length of the gap. For a typical one hour daylight savings change, the local date-time will be moved one hour later into the offset typically corresponding to "summer".

      Parameters:
      localDateTime - the local date-time, not null
      zone - the time-zone, not null
      preferredOffset - the zone offset, null if no preference
      Returns:
      the zoned date-time, not null

    • ofInstant

      public static ZonedDateTime ofInstant(Instant instant, ZoneId zone)
      Obtains an instance of ZonedDateTime from an Instant.

      This creates a zoned date-time with the same instant as that specified. Calling ChronoZonedDateTime.toInstant() will return an instant equal to the one used here.

      Converting an instant to a zoned date-time is simple as there is only one valid offset for each instant.

      Parameters:
      instant - the instant to create the date-time from, not null
      zone - the time-zone, not null
      Returns:
      the zoned date-time, not null
      Throws:
      DateTimeException - if the result exceeds the supported range

    • ofInstant

      public static ZonedDateTime ofInstant(LocalDateTime localDateTime, ZoneOffset offset, ZoneId zone)
      从由本地日期时间和偏移量组合而成的时刻获取 ZonedDateTime 的实例。

      通过 组合 LocalDateTime 和 ZoneOffset 来创建一个带时区的日期时间。这种组合唯一地指定了一个时刻，没有歧义。

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

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

      参数:
      localDateTime - 本地日期时间，非空
      offset - 时区偏移量，非空
      zone - 时区，非空
      返回:
      带时区的日期时间，非空

    • ofStrict

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

      通过确保偏移量对指定时区的本地日期时间有效来创建带时区的日期时间。如果偏移量无效，则会抛出异常。

      参数:
      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[Europe/Paris]"，非空
      返回:
      解析后的带时区的日期时间，非空
      抛出:
      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，则在此处实现查询。 支持的字段 将返回适当的范围实例。所有其他 ChronoField 实例将抛出 UnsupportedTemporalTypeException。

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

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

    • get

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

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

      如果字段是ChronoField，则在此处实现查询。基于此日期时间，受支持的字段将返回有效值，除了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，则在此处实现查询。基于此日期时间，受支持的字段将返回有效值。所有其他ChronoField实例将抛出UnsupportedTemporalTypeException。

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

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

    • getOffset

      public ZoneOffset getOffset()
      获取时区偏移，例如'+01:00'。

      这是本地日期时间与UTC/Greenwich之间的偏移量。

      指定者:
      getOffset 在接口 ChronoZonedDateTime<LocalDate>中
      返回值:
      时区偏移，不能为空

    • withEarlierOffsetAtOverlap

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

      当本地时间线重叠时，例如在秋季日光节约时间切换时，此方法才会产生任何效果。在这种情况下，本地日期时间有两个有效偏移。调用此方法将返回一个带有两者中较早者的分区日期时间。

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

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

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

    • withLaterOffsetAtOverlap

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

      当本地时间线重叠时，例如在秋季日光节约时间切换时，此方法才会产生任何效果。在这种情况下，本地日期时间有两个有效偏移。调用此方法将返回一个带有两者中较晚者的分区日期时间。

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

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

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

    • getZone

      public ZoneId getZone()
      获取时区，例如'Europe/Paris'。

      返回区域ID。这标识确定UTC/Greenwich偏移更改时间和方式的时区规则。

      区域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设置为偏移量。

      这将返回一个带有与 getOffset() 相同的时区ID的分区日期时间。结果的本地日期时间、偏移量和时刻将与此日期时间相同。

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

      这等效于 ZonedDateTime.of(zdt.toLocalDateTime(), zdt.getOffset())。

      返回值:
      带有偏移量设置为偏移量的 ZonedDateTime，不能为空

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

      此方法返回月份作为从 1 到 12 的 int。通过调用 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。调整器负责处理特殊情况，例如不同长度的月份和闰年。

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

        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 - 要使用的调整器，不能为空
      返回值:
      基于 this 进行调整后的 ZonedDateTime，不能为空
      抛出:
      DateTimeException - 如果无法进行调整
      ArithmeticException - 如果发生数值溢出

    • with

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

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

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

      如果字段是ChronoField，则在此处实现调整。

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

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

      其他支持的字段将按照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的副本。

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

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

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

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

    • withMonth

      public ZonedDateTime withMonth(int month)
      返回具有更改年份的此ZonedDateTime的副本。

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

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

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

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

    • withDayOfMonth

      public ZonedDateTime withDayOfMonth(int dayOfMonth)
      返回具有更改年份的此ZonedDateTime的副本。

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

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

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

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

    • withDayOfYear

      public ZonedDateTime withDayOfYear(int dayOfYear)
      返回具有更改年份的此ZonedDateTime的副本。

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

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

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

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

    • withHour

      public ZonedDateTime withHour(int hour)
      返回具有更改年份的此ZonedDateTime的副本。

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

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

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

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

    • withMinute

      public ZonedDateTime withMinute(int minute)
      返回具有更改年份的此ZonedDateTime的副本。

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

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

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

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

    • withSecond

      public ZonedDateTime withSecond(int second)
      返回具有更改后的分钟秒的此ZonedDateTime的副本。

      此操作在本地时间线上进行，更改本地日期时间的时间。然后使用区域ID将其转换回ZonedDateTime，以获取偏移量。

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

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

      参数：
      second - 要设置为结果的分钟秒，范围从0到59
      返回：
      基于此日期时间的ZonedDateTime，具有请求的秒，非空
      抛出：
      DateTimeException - 如果秒值无效

    • withNano

      public ZonedDateTime withNano(int nanoOfSecond)
      返回具有更改后的纳秒的此ZonedDateTime的副本。

      此操作在本地时间线上进行，更改本地日期时间的时间。然后使用区域ID将其转换回ZonedDateTime，以获取偏移量。

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

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

      参数：
      nanoOfSecond - 要设置为结果的纳秒，范围从0到999,999,999
      返回：
      基于此日期时间的ZonedDateTime，具有请求的纳秒，非空
      抛出：
      DateTimeException - 如果纳秒值无效

    • truncatedTo

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

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

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

      此操作在本地时间线上进行，截断基础本地日期时间。然后使用区域ID将其转换回ZonedDateTime，以获取偏移量。

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

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

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

    • plus

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

      这将返回一个ZonedDateTime，基于此日期时间，具有指定的添加量。该量通常是Period或Duration，但也可以是实现TemporalAmount接口的任何其他类型。

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

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

      在接口中指定：
      plus 在接口 ChronoZonedDateTime<LocalDate>
      在接口中指定：
      plus 在接口 Temporal
      参数：
      amountToAdd - 要添加的量，非空
      返回：
      基于此日期时间的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 - 要添加的数量的单位，非空
      返回：
      基于此日期时间的ZonedDateTime，具有指定添加量，非空
      抛出：
      DateTimeException - 如果无法进行添加
      UnsupportedTemporalTypeException - 如果不支持该单位
      ArithmeticException - 如果发生数值溢出

    • plusYears

      public ZonedDateTime plusYears(long years)
      返回具有指定年数的此ZonedDateTime的副本。

      这在本地时间线上操作，添加年份到本地日期时间。然后使用区域ID将其转换回ZonedDateTime，以获取偏移量。

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

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

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

    • plusMonths

      public ZonedDateTime plusMonths(long months)
      返回具有指定月数的此ZonedDateTime的副本。

      这在本地时间线上操作，添加月份到本地日期时间。然后使用区域ID将其转换回ZonedDateTime，以获取偏移量。

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

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

      参数:
      months - 要添加的月数，可以为负数
      返回:
      基于此日期时间的 ZonedDateTime，添加了月数，不为null
      抛出:
      DateTimeException - 如果结果超出支持的日期范围

    • plusWeeks

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

      这在本地时间线上操作，向本地日期时间添加周数。然后将其转换回 ZonedDateTime，使用区域ID获取偏移量。

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

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

      参数:
      weeks - 要添加的周数，可以为负数
      返回:
      基于此日期时间的 ZonedDateTime，添加了周数，不为null
      抛出:
      DateTimeException - 如果结果超出支持的日期范围

    • plusDays

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

      这在本地时间线上操作，向本地日期时间添加天数。然后将其转换回 ZonedDateTime，使用区域ID获取偏移量。

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

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

      参数:
      days - 要添加的天数，可以为负数
      返回:
      基于此日期时间的 ZonedDateTime，添加了天数，不为null
      抛出:
      DateTimeException - 如果结果超出支持的日期范围

    • plusHours

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

      这在瞬时时间线上操作，因此添加一个小时将始终是一个小时后的持续时间。这可能导致本地日期时间发生除一小时外的变化。请注意，这与天、月和年使用的方法不同，因此添加一天并不等同于添加 24 小时。

      例如，考虑一个时区，如 'Europe/Paris'，秋季 DST 切换意味着本地时间 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，添加了小时数，不为null
      抛出:
      DateTimeException - 如果结果超出支持的日期范围

    • plusMinutes

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

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

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

      参数:
      minutes - 要添加的分钟数，可以为负数
      返回:
      基于此日期时间的 ZonedDateTime，添加了分钟数，不为null
      抛出:
      DateTimeException - 如果结果超出支持的日期范围

    • plusSeconds

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

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

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

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

    • plusNanos

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

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

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

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

    • minus

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

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

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

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

      指定者:
      minus 在接口 ChronoZonedDateTime<LocalDate>
      指定者:
      minus 在接口 Temporal
      参数:
      amountToSubtract - 要减去的数量，不为null
      返回:
      基于此日期时间的 ZonedDateTime，进行了减法操作，不为null
      抛出:
      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 的副本。

      这在本地时间线上操作，将年份减去到本地日期时间。然后使用区域ID将其转换回 ZonedDateTime，以获取偏移量。

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

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

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

    • minusMonths

      public ZonedDateTime minusMonths(long months)
      返回一个减去指定月数的 ZonedDateTime 的副本。

      这在本地时间线上操作，将月份减去到本地日期时间。然后使用区域ID将其转换回 ZonedDateTime，以获取偏移量。

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

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

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

    • minusWeeks

      public ZonedDateTime minusWeeks(long weeks)
      返回一个减去指定周数的 ZonedDateTime 的副本。

      这在本地时间线上操作，将周数减去到本地日期时间。然后使用区域ID将其转换回 ZonedDateTime，以获取偏移量。

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

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

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

    • minusDays

      public ZonedDateTime minusDays(long days)
      返回一个减去指定天数的 ZonedDateTime 的副本。

      这在本地时间线上操作，将天数减去到本地日期时间。然后使用区域ID将其转换回 ZonedDateTime，以获取偏移量。

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

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

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

    • minusHours

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

      这在即时时间线上操作，因此减去一个小时将始终是一个小时较早的持续时间。这可能会导致本地日期时间发生不止一个小时的变化。请注意，这与天、月和年使用的方法不同，因此减去一天并不等同于添加 24 小时。

      例如，考虑一个时区，如 'Europe/Paris'，其中秋季 DST 切换意味着本地时间 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)：

         // 这两行是等效的
   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值将引发异常。

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

      日期单位在本地时间线上操作，使用本地日期时间。例如，在一天的中午到第二天中午之间的时间段将始终被计为一天，无论是否发生了夏令时更改。

      时间单位在即时时间线上操作。计算有效地将两个分区日期时间转换为即时，并计算两个即时之间的时间段。例如，在第一天中午到第二天中午之间的时间段可能是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
      返回值:
      如果此日期时间等于另一个日期时间，则为true
      参见:

    • 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中覆盖
      返回值:
      此日期时间的字符串表示，不能为空