ZonedDateTime (Java Platform SE 8 )

java.lang.Object
- java.time.ZonedDateTime

All Implemented Interfaces:

Serializable ， Comparable < ChronoZonedDateTime <？>>， ChronoZonedDateTime < LocalDate >， Temporal ， TemporalAccessor
```
public final class ZonedDateTime
extends Object
implements Temporal, ChronoZonedDateTime<LocalDate>, Serializable
```
ISO- 2007-12-03T10:15:30+01:00 Europe/Paris ，例如2007-12-03T10:15:30+01:00 Europe/Paris 。
ZonedDateTime是具有时区的日期时间的不可变表示。此类存储所有日期和时间字段，精度为纳秒，时区为区域偏移量，用于处理模糊的本地日期时间。例如，值“2007年10月2日在13：45.30.123456789 +欧洲/巴黎时区的+02：00”可以存储在ZonedDateTime 。

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

两个时间线之间的转换涉及计算使用的偏移rules从所访问的ZoneId 。获取瞬时的偏移是简单的，因为每个瞬间只有一个有效的偏移量。相比之下，获取本地日期时间的偏移量并不简单。有三种情况：
- 正常，有一个有效的偏移。在一年的绝大多数情况下，正常情况适用于当地日期时间单一有效抵消。
- 间隙，零有效偏移。这是由于春季夏令时从“冬季”变为“夏季”，时钟向前倾斜。在间隙中，存在没有有效偏移量的本地日期时间值。
- 重叠，有两个有效的偏移。这是由于秋季夏令时间从“夏季”变为“冬季”而将时钟倒退。在重叠中，存在具有两个有效偏移量的本地日期时间值。
任何通过获取偏移量从本地日期时间直接或隐式转换的方法都有可能变得复杂。

对于差距，总体策略是，如果当地日期时间落在一个差距的中间，那么由此产生的划分的日期时间将有一个本地日期时间向前移动距离的差距，导致一个日期 - 时间在后来的偏移，通常是“夏天”的时间。

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

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

这是一个value-based类; 使用身份敏感的操作（包括引用相等（的==上的实例），标识哈希码，或同步） ZonedDateTime可具有不可预测的结果，应当避免。 equals方法应用于比较。
实现要求：

A ZonedDateTime拥有相当于三个独立对象的状态，一个LocalDateTime ，一个ZoneId和解决的ZoneOffset 。偏移量和本地日期时间用于在必要时定义一个瞬间。区域ID用于获取偏移量如何以及何时更改的规则。偏移不能自由设置，因为区域控制哪些偏移是有效的。
这个类是不可变的和线程安全的。

从以下版本开始：

1.8

另请参见：

Serialized Form

方法摘要

所有方法静态方法接口方法具体的方法
Modifier and Type	Method and Description
`boolean`	`equals(Object obj)` 检查这个日期时间是否等于另一个日期时间。
`String`	`format(DateTimeFormatter formatter)` 使用指定的格式化程序格式化此日期时间。
`static ZonedDateTime`	`from(TemporalAccessor temporal)` 从时间对象获取一个 `ZonedDateTime`的实例。
`int`	`get(TemporalField field)` 从此日期时间获取指定字段的值为 `int` 。
`int`	`getDayOfMonth()` 获取月份字段。
`DayOfWeek`	`getDayOfWeek()` 获取星期几字段，这是一个枚举 `DayOfWeek` 。
`int`	`getDayOfYear()` 获得日期字段。
`int`	`getHour()` 获取时间字段。
`long`	`getLong(TemporalField field)` 从此日期时间获取指定字段的值作为 `long` 。
`int`	`getMinute()` 获取小时字段。
`Month`	`getMonth()` 使用 `Month`枚举获取月份字段。
`int`	`getMonthValue()` 将月份字段从1到12。
`int`	`getNano()` 获得纳秒第二场。
`ZoneOffset`	`getOffset()` 获取区域偏移量，例如“+01：00”。
`int`	`getSecond()` 获得第二分钟的字段。
`int`	`getYear()` 获取年份字段。
`ZoneId`	`getZone()` 获得时区，如“欧洲/巴黎”。
`int`	`hashCode()` 这个日期时间的哈希码。
`boolean`	`isSupported(TemporalField field)` 检查指定的字段是否受支持。
`boolean`	`isSupported(TemporalUnit unit)` 检查指定的单位是否受支持。
`ZonedDateTime`	`minus(long amountToSubtract, TemporalUnit unit)` 返回此日期时间的副本，并减去指定的金额。
`ZonedDateTime`	`minus(TemporalAmount amountToSubtract)` 返回此日期时间的副本，并减去指定的金额。
`ZonedDateTime`	`minusDays(long days)` 返回此 `ZonedDateTime`的副本，并以指定的时间段（以天为单位）减去。
`ZonedDateTime`	`minusHours(long hours)` 以指定的时间段返回此 `ZonedDateTime`的副本， `ZonedDateTime`数字。
`ZonedDateTime`	`minusMinutes(long minutes)` 返回此 `ZonedDateTime`的副本，其中指定的时间间隔以分钟为单位。
`ZonedDateTime`	`minusMonths(long months)` 返回此 `ZonedDateTime`的副本，指定的时间以月为单位减去。
`ZonedDateTime`	`minusNanos(long nanos)` 返回这个 `ZonedDateTime`的副本，以指定的时间减去纳秒。
`ZonedDateTime`	`minusSeconds(long seconds)` 返回此 `ZonedDateTime`的副本，其中指定的时间间隔以秒为单位。
`ZonedDateTime`	`minusWeeks(long weeks)` 以指定的周期返回此 `ZonedDateTime`的副本， `ZonedDateTime`星期。
`ZonedDateTime`	`minusYears(long years)` 返回此 `ZonedDateTime`的副本，并以减去的年份为单位。
`static ZonedDateTime`	`now()` 从默认时区的系统时钟获取当前的日期时间。
`static ZonedDateTime`	`now(Clock clock)` 从指定的时钟获取当前的日期时间。
`static ZonedDateTime`	`now(ZoneId zone)` 从指定时区的系统时钟获取当前的日期时间。
`static ZonedDateTime`	`of(int year, int month, int dayOfMonth, int hour, int minute, int second, int nanoOfSecond, ZoneId zone)` 从年，月，日，时，分，秒，纳秒和时区获取 `ZonedDateTime`的实例。
`static ZonedDateTime`	`of(LocalDate date, LocalTime time, ZoneId zone)` 从当地的日期和时间获取一个 `ZonedDateTime`的实例。
`static ZonedDateTime`	`of(LocalDateTime localDateTime, ZoneId zone)` 从本地日期时间获取 `ZonedDateTime`的实例。
`static ZonedDateTime`	`ofInstant(Instant instant, ZoneId zone)` 从 `Instant`获取一个 `ZonedDateTime`的实例。
`static ZonedDateTime`	`ofInstant(LocalDateTime localDateTime, ZoneOffset offset, ZoneId zone)` 从通过组合本地日期时间和偏移量形成的瞬间获取 `ZonedDateTime`的实例。
`static ZonedDateTime`	`ofLocal(LocalDateTime localDateTime, ZoneId zone, ZoneOffset preferredOffset)` 从本地日期时间获取 `ZonedDateTime`的实例，如果可能，使用首选偏移量。
`static ZonedDateTime`	`ofStrict(LocalDateTime localDateTime, ZoneOffset offset, ZoneId zone)` 获取 `ZonedDateTime`的实例，严格验证本地日期时间，偏移量和区域ID的组合。
`static ZonedDateTime`	`parse(CharSequence text)` 从文本字符串（例如 `2007-12-03T10:15:30+01:00[Europe/Paris]`获取一个 `ZonedDateTime`的实例。
`static ZonedDateTime`	`parse(CharSequence text, DateTimeFormatter formatter)` 从使用特定格式化程序的文本字符串获取一个 `ZonedDateTime`的实例。
`ZonedDateTime`	`plus(long amountToAdd, TemporalUnit unit)` 返回此日期时间的副本，并添加指定的金额。
`ZonedDateTime`	`plus(TemporalAmount amountToAdd)` 返回此日期时间的副本，并添加指定的金额。
`ZonedDateTime`	`plusDays(long days)` 返回此 `ZonedDateTime`的副本，其中指定的时间段以天添加。
`ZonedDateTime`	`plusHours(long hours)` 返回此 `ZonedDateTime`的副本，其指定时间以小时为单位。
`ZonedDateTime`	`plusMinutes(long minutes)` 以指定的时间段返回此 `ZonedDateTime`的副本，以分钟为单位。
`ZonedDateTime`	`plusMonths(long months)` 返回此 `ZonedDateTime`的副本，其中指定的时间段以月为单位。
`ZonedDateTime`	`plusNanos(long nanos)` 返回此 `ZonedDateTime`的副本，其指定时间以纳秒为单位。
`ZonedDateTime`	`plusSeconds(long seconds)` 返回此 `ZonedDateTime`的副本，并以指定的时间段（以秒为单位）添加。
`ZonedDateTime`	`plusWeeks(long weeks)` 返回这个 `ZonedDateTime`的副本，并以指定的周期添加周数。
`ZonedDateTime`	`plusYears(long years)` 返回这个 `ZonedDateTime`的副本，并以指定的时间段添加。
`<R> R`	`query(TemporalQuery<R> query)` 使用指定的查询查询此日期时间。
`ValueRange`	`range(TemporalField field)` 获取指定字段的有效值的范围。
`LocalDate`	`toLocalDate()` 获得这个日期时间的 `LocalDate`部分。
`LocalDateTime`	`toLocalDateTime()` 获得这个日期时间的 `LocalDateTime`部分。
`LocalTime`	`toLocalTime()` 获得这个日期时间的 `LocalTime`部分。
`OffsetDateTime`	`toOffsetDateTime()` 将此日期时间转换为 `OffsetDateTime` 。
`String`	`toString()` 将此日期时间输出为 `String` ，例如 `2007-12-03T10:15:30+01:00[Europe/Paris]` 。
`ZonedDateTime`	`truncatedTo(TemporalUnit unit)` 返回这个 `ZonedDateTime`的副本，其 `ZonedDateTime`时间。
`long`	`until(Temporal endExclusive, TemporalUnit unit)` 根据指定的单位计算到另一个日期时间的时间量。
`ZonedDateTime`	`with(TemporalAdjuster adjuster)` 返回此日期时间的调整副本。
`ZonedDateTime`	`with(TemporalField field, long newValue)` 返回此日期时间的副本，并将指定的字段设置为新值。
`ZonedDateTime`	`withDayOfMonth(int dayOfMonth)` 返回这个 `ZonedDateTime`的副本，日期值更改。
`ZonedDateTime`	`withDayOfYear(int dayOfYear)` 返回此 `ZonedDateTime`的副本，并更改日期。
`ZonedDateTime`	`withEarlierOffsetAtOverlap()` 将本日期时间的副本返回到本地时间线重叠处，将区域偏移更改为两个有效偏移量的较早者。
`ZonedDateTime`	`withFixedOffsetZone()` 返回此日期时间的副本，区域ID设置为偏移量。
`ZonedDateTime`	`withHour(int hour)` 返回此 `ZonedDateTime`的副本，并更改日期值。
`ZonedDateTime`	`withLaterOffsetAtOverlap()` 返回此日期的副本，将区域偏移更改为本地时间线重叠的两个有效偏移量的后面。
`ZonedDateTime`	`withMinute(int minute)` 返回这个 `ZonedDateTime`的副本，小时值更改。
`ZonedDateTime`	`withMonth(int month)` 返回这个 `ZonedDateTime`的副本，年月值被更改。
`ZonedDateTime`	`withNano(int nanoOfSecond)` 返回这个 `ZonedDateTime`的副本，纳秒变化值。
`ZonedDateTime`	`withSecond(int second)` 返回这个 `ZonedDateTime`的副本，其中二分之一值更改。
`ZonedDateTime`	`withYear(int year)` 返回这个 `ZonedDateTime`的年份值更改的副本。
`ZonedDateTime`	`withZoneSameInstant(ZoneId zone)` 使用不同的时区返回此日期时间的副本，保留即时。
`ZonedDateTime`	`withZoneSameLocal(ZoneId zone)` 使用不同的时区返回此日期时间的副本，如果可能，保留本地日期时间。

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface java.time.chrono.ChronoZonedDateTime
compareTo, getChronology, isAfter, isBefore, isEqual, timeLineOrder, toEpochSecond, toInstant

- 方法详细信息
  - 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 - 要使用的时钟，不为空
    
    结果
    
    当前日期时间，不为null
  - of
```
public static ZonedDateTime of(LocalDate date,
                               LocalTime time,
                               ZoneId zone)
```
    从当地的日期和时间获取ZonedDateTime的实例。
    这将创建一个划分的日期时间，尽可能地将输入的本地日期和时间进行匹配。时区规则（如夏令时）意味着并非每个本地日期时间对指定的区域都有效，因此可能会调整本地日期时间。
    
    当地的日期时间，首先结合形成当地的日期时间。然后，本地日期时间在时间线上解析为单个时刻。这是通过从区域ID的rules定义的本地日期时间中找到UTC /格林威治的有效偏移量来实现的。
    
    在大多数情况下，本地日期时间只有一个有效的偏移量。在重叠的情况下，当设置时钟时，有两个有效的偏移量。该方法使用通常对应于“summer”的较早的偏移量。
    
    在间隙的情况下，当时钟向前跳转时，没有有效的偏移。相反，本地日期时间被调整为稍后间隔的长度。对于典型的1小时夏令时更改，本地日期时间将在一小时后移动到通常对应于“夏季”的偏移量。
    
    参数
    
    date - 本地日期，不为null
    
    time - 当地时间，不为空
    
    zone - 时区，不为空
    
    结果
    
    偏移日期时间，不为null
  - of
```
public static ZonedDateTime of(LocalDateTime localDateTime,
                               ZoneId zone)
```
    从当地的日期时间获取一个ZonedDateTime的实例。
    这将创建一个与输入本地日期时间相匹配的划分的日期时间。时区规则（如夏令时）意味着并非每个本地日期时间对指定的区域都有效，因此可能会调整本地日期时间。
    
    本地日期时间在时间线上解析为单个时刻。这是通过从区域ID的rules定义的本地日期时间中找到UTC /格林威治的有效偏移量来实现的。
    
    在大多数情况下，本地日期时间只有一个有效的偏移量。在重叠的情况下，当设置时钟时，有两个有效的偏移量。该方法使用通常对应于“summer”的较早的偏移量。
    
    在间隙的情况下，当时钟向前跳转时，没有有效的偏移。相反，本地日期时间被调整为稍后间隔的长度。对于典型的1小时夏令时更改，本地日期时间将在一小时后移动到通常对应于“夏季”的偏移量。
    
    参数
    
    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 /格林威治的有效偏移量来实现的。
    
    在大多数情况下，本地日期时间只有一个有效的偏移量。在重叠的情况下，当设置时钟时，有两个有效的偏移量。该方法使用通常对应于“summer”的较早的偏移量。
    
    在间隙的情况下，当时钟向前跳转时，没有有效的偏移。相反，本地日期时间被调整为稍后间隔的长度。对于典型的1小时夏令时更改，本地日期时间将在一小时后移动到通常对应于“夏季”的偏移量。
    
    该方法主要用于编写测试用例。非测试代码通常会使用其他方法来创建一个偏移时间。 LocalDateTime具有相同工厂方法的五个附加便利变体，其参数较少。在这里不提供它们来减少API的占用空间。
    
    参数
    
    year - 从MIN_YEAR到MAX_YEAR的年份
    
    month - 从1月1日至12日（12月）的月份，
    
    dayOfMonth - 代表从1到31的月份
    
    hour - 代表从0到23的小时
    
    minute - 从0到59表示的小时
    
    second - 从0到59的秒表示
    
    nanoOfSecond - 表示从0到999,999,999的纳秒
    
    zone - 时区，不为空
    
    结果
    
    偏移日期时间，不为null
    
    异常
    
    DateTimeException - 如果任何字段的值超出范围，或者如果月的日期对于月份无效
  - ofLocal
```
public static ZonedDateTime ofLocal(LocalDateTime localDateTime,
                                    ZoneId zone,
                                    ZoneOffset preferredOffset)
```
    从本地日期时间获取ZonedDateTime的实例，如果可能，使用首选偏移量。
    本地日期时间在时间线上解析为单个时刻。这是通过从区域ID的rules定义的本地日期时间中找到UTC /格林威治的有效偏移量来实现的。
    
    在大多数情况下，本地日期时间只有一个有效的偏移量。在重叠的情况下，时钟被设置回来，有两个有效的偏移量。如果首选偏移量是有效偏移之一，则使用它。否则，将使用较早的有效偏移量，通常对应于“summer”。
    
    在间隙向前跳跃的情况下，没有有效的偏移。相反，本地日期时间被调整为稍后间隔的长度。对于典型的1小时夏令时更改，本地日期时间将在一小时后移动到通常对应于“夏季”的偏移量。
    
    参数
    
    localDateTime - 本地日期时间，不为空
    
    zone - 时区，不为空
    
    preferredOffset - 区域偏移量，如果没有偏好，则为null
    
    结果
    
    划分的日期时间，不为空
  - ofInstant
```
public static ZonedDateTime ofInstant(Instant instant,
                                      ZoneId zone)
```
    从Instant获得ZonedDateTime的一个Instant 。
    这将创建一个与指定的时间相同的分区日期时间。调用ChronoZonedDateTime.toInstant()将返回等于这里使用的时刻。
    
    将瞬间转换为划分的日期时间很简单，因为每个时刻只有一个有效的偏移量。
    
    参数
    
    instant - 即时创建日期时间，不为null
    
    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 - 时区，不为空
    
    结果
    
    划分的日期时间，不为空
  - from
```
public static ZonedDateTime from(TemporalAccessor temporal)
```
    从时间对象获取一个ZonedDateTime的实例。
    这将根据指定的时间获得一个划区的日期时间。 A TemporalAccessor表示一个任意的日期和时间信息集，该工厂转换为ZonedDateTime一个实例。
    
    转换将第一获得ZoneId从时间对象，回落到一个ZoneOffset如果必要的话。然后，它会尝试获得Instant ，回落到LocalDateTime ，如果必要的。结果将是ZoneId或ZoneOffset与Instant或LocalDateTime 。允许实现执行优化，例如访问与相关对象相当的那些字段。
    
    该方法中，功能接口的签名相匹配TemporalQuery允许它在通过方法参考，查询中使用ZonedDateTime::from 。
    
    Specified by:
    
    from中的 ChronoZonedDateTime<LocalDate>
    
    参数
    
    temporal - 要转换的时间对象，不为null
    
    结果
    
    划分的日期时间，不为空
    
    异常
    
    DateTimeException - 如果无法转换为 ZonedDateTime
    
    另请参见：
    
    Chronology.zonedDateTime(TemporalAccessor)
  - 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 - 使用的格式化程序，不为null
    
    结果
    
    解析的分区日期时间，不为空
    
    异常
    
    DateTimeParseException - 如果文本无法解析
  - isSupported
```
public boolean isSupported(TemporalField field)
```
    检查指定的字段是否受支持。
    这将检查是否可以查询指定字段的日期时间。如果是假，然后调用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作为参数获得的。字段是否受支持由字段决定。
    Specified by:
    
    isSupported在界面 ChronoZonedDateTime<LocalDate>
    
    Specified by:
    
    isSupported在接口 TemporalAccessor
    
    参数
    
    field - 要检查的字段，null返回假
    
    结果
    
    如果在此日期时间内支持该字段，则为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作为参数。设备是否受支持由本机决定。
    Specified by:
    
    isSupported在接口 ChronoZonedDateTime<LocalDate>
    
    Specified by:
    
    isSupported在接口 Temporal
    
    参数
    
    unit - 要检查的单位，null返回false
    
    结果
    
    如果可以添加/减去单位，则为真，否则为false
  - range
```
public ValueRange range(TemporalField field)
```
    获取指定字段的有效值的范围。
    范围对象表示字段的最小和最大有效值。此日期时间用于提高返回范围的准确性。如果不可能返回范围，因为该字段不受支持或出于某种其他原因，则抛出异常。
    
    如果该字段是ChronoField，那么查询是在这里实现的。 supported fields将返回适当的范围实例。所有其他ChronoField实例将抛出一个UnsupportedTemporalTypeException 。
    
    如果该字段不是ChronoField ，则该方法的结果是通过调用TemporalField.rangeRefinedBy(TemporalAccessor)通过this作为参数获得的。是否可以获得范围由字段确定。
    
    Specified by:
    
    range在接口 ChronoZonedDateTime<LocalDate>
    
    Specified by:
    
    range中的 TemporalAccessor
    
    参数
    
    field - 查询范围的字段，不为null
    
    结果
    
    字段的有效值的范围不为null
    
    异常
    
    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 ，并抛出一个DateTimeException 。所有其他ChronoField实例会抛出一个UnsupportedTemporalTypeException 。
    
    如果该字段是不是一个ChronoField ，则此方法的结果是通过调用获得TemporalField.getFrom(TemporalAccessor)传递this作为参数。该值是否可以获得，该值代表什么值由该字段决定。
    
    Specified by:
    
    get在接口 ChronoZonedDateTime<LocalDate>
    
    Specified by:
    
    get在接口 TemporalAccessor
    
    参数
    
    field - 要获取的字段，不为空
    
    结果
    
    该字段的值
    
    异常
    
    DateTimeException - 如果无法获取该字段的值或该值超出该字段的有效值的范围
    
    UnsupportedTemporalTypeException - 如果该字段不受支持或值范围超过 int
    
    ArithmeticException - 如果发生数字溢出
  - getLong
```
public long getLong(TemporalField field)
```
    从此日期时间获取指定字段的值为long 。
    这将查询指定字段的值的日期时间。如果不可能返回值，因为该字段不受支持或出于某种其他原因，则抛出异常。
    
    如果该字段是ChronoField，那么查询是在这里实现的。 supported fields将根据此日期时间返回有效值。所有其他ChronoField实例都会抛出UnsupportedTemporalTypeException 。
    
    如果该字段是不是一个ChronoField ，则此方法的结果是通过调用获得TemporalField.getFrom(TemporalAccessor)传递this作为参数。该值是否可以获得，该值代表什么值由该字段决定。
    
    Specified by:
    
    getLong在接口 ChronoZonedDateTime<LocalDate>
    
    Specified by:
    
    getLong在接口 TemporalAccessor
    
    参数
    
    field - 要获取的字段，不为空
    
    结果
    
    该字段的值
    
    异常
    
    DateTimeException - 如果无法获取字段的值
    
    UnsupportedTemporalTypeException - 如果该字段不被支持
    
    ArithmeticException - 如果发生数字溢出
  - getOffset
```
public ZoneOffset getOffset()
```
    获取区域偏移量，例如“+01：00”。
    这是当地时间与UTC /格林威治的抵消。
    
    Specified by:
    
    getOffset在接口 ChronoZonedDateTime<LocalDate>
    
    结果
    
    区域偏移，不为空
  - withEarlierOffsetAtOverlap
```
public ZonedDateTime withEarlierOffsetAtOverlap()
```
    将本日期时间的副本返回到本地时间线重叠处，将区域偏移更改为两个有效偏移量的较早者。
    当本地时间线重叠时，例如在秋季夏令时切换时，此方法仅有效果。在这种情况下，本地日期时间有两个有效的偏移量。调用此方法将返回一个分区的日期时间，其中选择的两个之前的早期。
    
    如果在不重叠的情况下调用此方法，则返回this 。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    withEarlierOffsetAtOverlap在接口 ChronoZonedDateTime<LocalDate>
    
    结果
    
    一个 ZonedDateTime基于这个日期时间与较早的偏移量，不为null
  - withLaterOffsetAtOverlap
```
public ZonedDateTime withLaterOffsetAtOverlap()
```
    返回此日期的副本，将区域偏移更改为本地时间线重叠的两个有效偏移量的后面。
    当本地时间线重叠时，例如在秋季夏令时切换时，此方法仅有效果。在这种情况下，本地日期时间有两个有效的偏移量。调用此方法将返回一个分区的日期时间，后两个选择。
    
    如果在不重叠的情况下调用此方法，则返回this 。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    withLaterOffsetAtOverlap在接口 ChronoZonedDateTime<LocalDate>
    
    结果
    
    一个 ZonedDateTime基于这个日期时间与稍后的偏移量，不为null
  - getZone
```
public ZoneId getZone()
```
    获得时区，如“欧洲/巴黎”。
    这将返回区域ID。这标识了时区rules ，它决定了UTC /格林威治的偏移量何时以及如何变化。
    
    区号可能与offset相同。如果这是真的，那么任何未来的计算（如加法或减法）都不会因时区规则而复杂的边缘情况。参见withFixedOffsetZone() 。
    
    Specified by:
    
    getZone在接口 ChronoZonedDateTime<LocalDate>
    
    结果
    
    时区，不为空
  - withZoneSameLocal
```
public ZonedDateTime withZoneSameLocal(ZoneId zone)
```
    使用不同的时区返回此日期时间的副本，如果可能，保留本地日期时间。
    此方法更改时区并保留本地日期时间。如果对于新区域无效，则本地日期时间将被更改，使用与ofLocal(LocalDateTime, ZoneId, ZoneOffset)相同的方法确定。
    
    要更改区域并调整本地日期时间，请使用withZoneSameInstant(ZoneId) 。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    withZoneSameLocal在接口 ChronoZonedDateTime<LocalDate>
    
    参数
    
    zone - 时区改为，不为空
    
    结果
    
    一个 ZonedDateTime基于此日期时间与请求的区域，不为null
  - withZoneSameInstant
```
public ZonedDateTime withZoneSameInstant(ZoneId zone)
```
    使用不同的时区返回此日期时间的副本，保留即时。
    该方法更改时区并保留即时。这通常会导致本地日期时间的更改。
    
    该方法基于保留相同的时刻，因此本地时间线上的间隙和重叠对结果没有影响。
    
    要保持本地时间更改偏移量，请使用withZoneSameLocal(ZoneId) 。
    
    Specified by:
    
    withZoneSameInstant在接口 ChronoZonedDateTime<LocalDate>
    
    参数
    
    zone - 时区改为，不为空
    
    结果
    
    一个 ZonedDateTime基于此日期时间与请求的区域，不为null
    
    异常
    
    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 。
    
    Specified by:
    
    toLocalDateTime在接口 ChronoZonedDateTime<LocalDate>
    
    结果
    
    这个日期时间的本地日期时间部分，不为空
  - toLocalDate
```
public LocalDate toLocalDate()
```
    获得这个日期时间的LocalDate部分。
    这将返回与此日期时间相同年份，月份和日期的LocalDate 。
    
    Specified by:
    
    toLocalDate在接口 ChronoZonedDateTime<LocalDate>
    
    结果
    
    此日期时间的日期部分不为null
  - getYear
```
public int getYear()
```
    获取年份字段。
    此方法返回一年的int值int值。
    
    通过这种方法返回的年份是根据get(YEAR)是get(YEAR) 。要获得年龄，使用get(YEAR_OF_ERA) 。
    
    结果
    
    年，从MIN_YEAR到MAX_YEAR
  - getMonthValue
```
public int getMonthValue()
```
    将月份字段从1到12。
    该方法将从8月1日起的int的月份返回到12。如果通过调用getMonth()使用枚举Month ，应用程序代码通常会更加清晰。
    
    结果
    
    从1到12年的月份
    
    另请参见：
    
    getMonth()
  - getMonth
```
public Month getMonth()
```
    使用Month枚举获取月份字段。
    此方法返回本月的枚举Month 。这避免了对int值意味着什么的int 。如果您需要访问原始的int值，那么枚举将提供int value 。
    
    结果
    
    月份，不为零
    
    另请参见：
    
    getMonthValue()
  - getDayOfMonth
```
public int getDayOfMonth()
```
    获取月份字段。
    此方法返回月份的int值int值。
    
    结果
    
    从1到31日
  - getDayOfYear
```
public int getDayOfYear()
```
    获得日期字段。
    此方法返回原始年份int值。
    
    结果
    
    一年中，从1到365，或闰年366
  - getDayOfWeek
```
public DayOfWeek getDayOfWeek()
```
    获取星期几字段，这是一个枚举DayOfWeek 。
    此方法返回星期几的枚举DayOfWeek 。这避免了对int值意味着什么的int 。如果您需要访问原始的int值，那么枚举将提供int value 。
    
    附加信息可以从DayOfWeek获得。这包括值的文本名称。
    
    结果
    
    星期几不为零
  - toLocalTime
```
public LocalTime toLocalTime()
```
    获得这个日期时间的LocalTime部分。
    这将返回一个LocalTime与这个日期时间相同的小时，分钟，秒和纳秒。
    
    Specified by:
    
    toLocalTime在界面 ChronoZonedDateTime<LocalDate>
    
    结果
    
    这个日期时间的一部分，不是null
  - 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 ，基于这一个，日期时间被调整。调整使用指定的调整器策略对象进行。阅读调整器的文档，了解将进行什么调整。
    
    一个简单的调整器可能只是设置一个字段，如年份字段。更复杂的调整器可能会将日期设置为该月的最后一天。 TemporalAdjuster中提供了一些常见的调整。这些包括找到“月的最后一天”和“下周三”。关键的日期时间课程也实现了TemporalAdjuster界面，如Month和MonthDay 。调整员负责处理特殊情况，如月份和闰年的不同长度。
    
    例如这个代码在7月的最后一天返回一个日期：
```
  import static java.time.Month.*;
  import static java.time.temporal.Adjusters.*;

  result = zonedDateTime.with(JULY).with(lastDayOfMonth()); 
```
    类LocalDate和LocalTime实现TemporalAdjuster ，因此该方法可用于更改日期，时间或偏移量：
```
  result = zonedDateTime.with(date);
  result = zonedDateTime.with(time); 
```
    ZoneOffset也实现了TemporalAdjuster但是使用它作为参数通常没有影响。 ZonedDateTime的偏移量主要由时区控制。因此，更改偏移量通常不会有意义，因为本地日期时间和区域只有一个有效的偏移量。如果划分的日期时间与夏令时重叠，则偏移量用于在两个有效偏移之间切换。在所有其他情况下，偏移量将被忽略。
    
    该方法的结果是通过调用TemporalAdjuster.adjustInto(Temporal)方法在指定的调整器上通过this作为参数。
    
    此实例是不可变的，不受此方法调用的影响。
    Specified by:
    
    with在接口 ChronoZonedDateTime<LocalDate>
    
    Specified by:
    
    with在界面 Temporal
    
    参数
    
    adjuster - 调整器使用，不为空
    
    结果
    
    一个 ZonedDateTime基于 this进行了调整，不为null
    
    异常
    
    DateTimeException - 如果不能进行调整
    
    ArithmeticException - 如果发生数字溢出
  - with
```
public ZonedDateTime with(TemporalField field,
                          long newValue)
```
    返回此日期时间的副本，并将指定的字段设置为新值。
    这将返回一个ZonedDateTime ，基于此一个，指定字段的值更改。这可以用于更改任何支持的字段，例如年，月或月。如果不可能设置该值，因为该字段不受支持或出于某种其他原因，则抛出异常。
    
    在某些情况下，更改指定的字段可能会导致生成的日期时间变得无效，例如将月份从1月31日更改为2月将导致日期无效。在这种情况下，该领域负责解决日期。通常，它将选择先前的有效日期，这将是本例中最后一个有效的二月份。
    
    如果该字段是ChronoField，则在此处实现调整。
    
    INSTANT_SECONDS字段将返回指定时间的日期时间。区域和纳秒不变。结果将具有来自新的即时和原始区域的偏移。如果新的即时值超出有效范围，则将抛出DateTimeException 。
    
    通常会忽略OFFSET_SECONDS字段。 ZonedDateTime的偏移量主要由时区控制。因此，更改偏移量通常不会有意义，因为本地日期时间和区域只有一个有效的偏移量。如果划分的日期时间与夏令时重叠，则偏移量用于在两个有效偏移之间切换。在所有其他情况下，偏移量将被忽略。如果新的偏移值超出有效范围，那么将抛出一个DateTimeException 。
    
    另一个supported fields将按照LocalDateTime的匹配方法进行操作。该区域不是计算的一部分，将不变。当转换回ZonedDateTime时，如果本地日期时间处于重叠状态，则可能会保留偏移量，否则将使用较早的偏移量。如果有差距，当地的日期时间将按差距的长短进行调整。
    
    所有其他ChronoField实例都会抛出一个UnsupportedTemporalTypeException 。
    
    如果该字段是不是一个ChronoField ，则此方法的结果是通过调用获得TemporalField.adjustInto(Temporal, long)传递this作为参数。在这种情况下，该字段决定是否以及如何调整即时。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    with在接口 ChronoZonedDateTime<LocalDate>
    
    Specified by:
    
    with在接口 Temporal
    
    参数
    
    field - 要在结果中设置的字段，不为空
    
    newValue - 结果中字段的新值
    
    结果
    
    一个 ZonedDateTime基于 this与指定的字段设置，不为null
    
    异常
    
    DateTimeException - 如果字段无法设置
    
    UnsupportedTemporalTypeException - 如果该字段不被支持
    
    ArithmeticException - 如果发生数字溢出
  - withYear
```
public ZonedDateTime withYear(int year)
```
    返回这个ZonedDateTime的年份值更改的副本。
    这是在当地时间线当地时间changing the year运行的。然后将其转换回ZonedDateTime ，使用区域ID获取偏移量。
    
    当转换回ZonedDateTime时，如果本地日期时间重叠，则可能会保留偏移量，否则将使用较早的偏移量。如果有差距，当地的日期时间将按差距的长短进行调整。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    year - 从MIN_YEAR到MAX_YEAR的结果年份
    
    结果
    
    一个 ZonedDateTime基于这个日期时间与请求的年份，不为null
    
    异常
    
    DateTimeException - 如果年值无效
  - withMonth
```
public ZonedDateTime withMonth(int month)
```
    返回这个ZonedDateTime的副本， ZonedDateTime更改月份值。
    这是在当地时间线当地时间changing the month运行的。然后将其转换回ZonedDateTime ，使用区域ID获取偏移量。
    
    当转换回ZonedDateTime时，如果本地日期时间重叠，则可能会保留偏移量，否则将使用较早的偏移量。如果有差距，当地的日期时间将按差距的长短进行调整。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    month - 从1月1日至12日（12月），确定结果的月份
    
    结果
    
    一个 ZonedDateTime基于这个日期时间与请求的月份，不为null
    
    异常
    
    DateTimeException - 如果月份值无效
  - withDayOfMonth
```
public ZonedDateTime withDayOfMonth(int dayOfMonth)
```
    返回此ZonedDateTime的副本，并ZonedDateTime日期值。
    这是在当地时间线当地时间的changing the day-of-month运行。然后将其转换回ZonedDateTime ，使用区域ID获取偏移量。
    
    当转换回ZonedDateTime时，如果本地日期时间重叠，则可能会保留偏移量，否则将使用较早的偏移量。如果有差距，当地的日期时间将按差距的长短进行调整。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    dayOfMonth - 在1月28日至31日之间的结果中设定的月份
    
    结果
    
    一个 ZonedDateTime基于这个日期时间与请求的一天，不为null
    
    异常
    
    DateTimeException - 如果月日的价值无效，或者月的日期对于月份无效
  - withDayOfYear
```
public ZonedDateTime withDayOfYear(int dayOfYear)
```
    返回此ZonedDateTime的副本，并更改日期。
    这是在本地时间线上运行的，当地的日期时间是changing the day-of-year 。然后将其转换回ZonedDateTime ，使用区域ID获取偏移量。
    
    当转换回ZonedDateTime时，如果本地日期时间重叠，则可能会保留偏移量，否则将使用较早的偏移量。如果有差距，当地的日期时间将按差距的长短进行调整。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    dayOfYear - 设定结果的日期，从1到365-366
    
    结果
    
    一个 ZonedDateTime基于此日期与请求的日期，不为null
    
    异常
    
    DateTimeException - 如果日期年值无效，或者如果当年的无效年份
  - withHour
```
public ZonedDateTime withHour(int hour)
```
    返回此ZonedDateTime的副本，并更改日期值。
    这是在当地时间线当地时间的changing the time运行。然后将其转换回ZonedDateTime ，使用区域ID获取偏移量。
    
    当转换回ZonedDateTime时，如果本地日期时间处于重叠状态，则可能会保留偏移量，否则将使用较早的偏移量。如果有差距，当地的日期时间将按差距的长短进行调整。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    hour - 设置结果的时刻，从0到23
    
    结果
    
    一个 ZonedDateTime基于这个日期时间与请求的小时，不为null
    
    异常
    
    DateTimeException - 如果小时值无效
  - withMinute
```
public ZonedDateTime withMinute(int minute)
```
    返回这个ZonedDateTime的副本，小时值更改。
    这是在本地时间线当地日期时间的changing the time运行。然后将其转换回ZonedDateTime ，使用区域ID获取偏移量。
    
    当转换回ZonedDateTime时，如果本地日期时间处于重叠状态，则可能会保留偏移量，否则将使用较早的偏移量。如果有差距，当地的日期时间将按差距的长短进行调整。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    minute - 在0到59之间设置的小时
    
    结果
    
    一个 ZonedDateTime基于这个日期时间与请求的分钟，不为null
    
    异常
    
    DateTimeException - 如果分钟值无效
  - withSecond
```
public ZonedDateTime withSecond(int second)
```
    返回这个ZonedDateTime的副本，其中二分之一值更改。
    这是在当地时间线当地时间changing the time运行。然后将其转换回ZonedDateTime ，使用区域ID获取偏移量。
    
    当转换回ZonedDateTime时，如果本地日期时间重叠，则可能会保留偏移量，否则将使用较早的偏移量。如果有差距，当地的日期时间将按差距的长短进行调整。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    second - 在0到59之间设置结果的 second
    
    结果
    
    一个 ZonedDateTime基于这个日期时间与请求的秒，不为null
    
    异常
    
    DateTimeException - 如果第二个值无效
  - withNano
```
public ZonedDateTime withNano(int nanoOfSecond)
```
    返回这个ZonedDateTime的副本，纳秒变化值。
    这在当地的时间线当地的日期时间是changing the time 。然后将其转换回ZonedDateTime ，使用区域ID获取偏移量。
    
    当转换回ZonedDateTime时，如果本地日期时间重叠，则可能会保留偏移量，否则将使用较早的偏移量。如果有差距，当地的日期时间将按差距的长短进行调整。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    nanoOfSecond - 纳秒的设定结果，从0到999,999,999
    
    结果
    
    一个 ZonedDateTime基于这个日期时间与请求的纳秒，不为null
    
    异常
    
    DateTimeException - 如果纳米值无效
  - truncatedTo
```
public ZonedDateTime truncatedTo(TemporalUnit unit)
```
    返回此ZonedDateTime的副本， ZonedDateTime时间。
    截断返回原始日期时间的副本，其中小于指定单位的字段设置为零。例如，使用minutes单元进行截断将将第二分钟和第二纳秒字段设置为零。
    
    该单位必须有一个duration ，分为标准日期的长度，无余数。这包括所有提供的时间单位ChronoUnit和DAYS 。其他单位抛出异常。
    
    这是在本地时间线上操作的，当地时间是truncating。然后将其转换回ZonedDateTime ，使用区域ID获取偏移量。
    
    当转换回ZonedDateTime时，如果本地日期时间重叠，则可能会保留偏移量，否则将使用较早的偏移量。如果有差距，当地的日期时间将按差距的长短进行调整。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    unit - 截断到的单位，不为null
    
    结果
    
    一个 ZonedDateTime基于这个日期时间截断的时间，不为null
    
    异常
    
    DateTimeException - 如果无法截断
    
    UnsupportedTemporalTypeException - 如果不支持本机
  - plus
```
public ZonedDateTime plus(TemporalAmount amountToAdd)
```
    返回此日期时间的副本，并添加指定的金额。
    这返回一个ZonedDateTime ，基于这一个，添加了指定的数量。量通常是Period或Duration ，而可以是任何其他类型的实现TemporalAmount接口。
    
    通过调用TemporalAmount.addTo(Temporal)将计算委托给金额对象。数量执行可以以任何方式实现添加，但是它通常会回调到plus(long, TemporalUnit) 。请参阅金额执行的文档，以确定是否可以成功添加。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    plus在接口 ChronoZonedDateTime<LocalDate>
    
    Specified by:
    
    plus在接口 Temporal
    
    参数
    
    amountToAdd - 要添加的金额，不为null
    
    结果
    
    一个 ZonedDateTime基于这个日期时间与添加，而不是null
    
    异常
    
    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作为参数。在这种情况下，单元确定是否以及如何执行添加。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    plus中的 ChronoZonedDateTime<LocalDate>
    
    Specified by:
    
    plus在界面 Temporal
    
    参数
    
    amountToAdd - 添加到结果中的单位数量可能为负数
    
    unit - 要添加的单位，不为null
    
    结果
    
    一个 ZonedDateTime基于此日期时间与指定的数量添加，不为null
    
    异常
    
    DateTimeException - 如果不能添加
    
    UnsupportedTemporalTypeException - 如果不支持本机
    
    ArithmeticException - 如果发生数字溢出
  - plusYears
```
public ZonedDateTime plusYears(long years)
```
    返回此ZonedDateTime的副本，并以指定的时间段添加。
    这将按当地时间线adding years运行到当地的日期。然后将其转换回ZonedDateTime ，使用区域ID获取偏移量。
    
    当转换回ZonedDateTime时，如果本地日期时间重叠，则可能会保留偏移量，否则将使用较早的偏移量。如果有差距，当地的日期时间将按差距的长短进行调整。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    years - 多年来补充，可能是负数
    
    结果
    
    一个 ZonedDateTime基于这个日期时间与添加的年份，不为null
    
    异常
    
    DateTimeException - 如果结果超出支持的日期范围
  - plusMonths
```
public ZonedDateTime plusMonths(long months)
```
    返回这个ZonedDateTime的副本，其中指定的时间段以月为单位。
    这将按当地时间线adding months运行到当地的日期。然后将其转换回ZonedDateTime ，使用区域ID获取偏移量。
    
    当转换回ZonedDateTime时，如果本地日期时间重叠，则可能会保留偏移量，否则将使用较早的偏移量。如果有差距，当地的日期时间将按差距的长短进行调整。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    months - 要补充的月份，可能为负数
    
    结果
    
    一个 ZonedDateTime基于这个日期时间与添加的月份，不为null
    
    异常
    
    DateTimeException - 如果结果超出支持的日期范围
  - plusWeeks
```
public ZonedDateTime plusWeeks(long weeks)
```
    以指定的周期返回此ZonedDateTime的副本，以周为单位。
    这是在本地时间线上运行的，当地的日期时间是adding weeks 。然后将其转换回ZonedDateTime ，使用区域ID获取偏移量。
    
    当转换回ZonedDateTime时，如果本地日期时间重叠，则可能会保留偏移量，否则将使用较早的偏移量。如果有差距，当地的日期时间将按差距的长短进行调整。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    weeks - 要添加的星期可能为负数
    
    结果
    
    一个 ZonedDateTime基于这个日期时间与添加的星期，不为null
    
    异常
    
    DateTimeException - 如果结果超出了支持的日期范围
  - plusDays
```
public ZonedDateTime plusDays(long days)
```
    返回指定期间的ZonedDateTime的副本， ZonedDateTime天数。
    这在本地时间线上运行，当地的日期时间是adding days 。然后将其转换回ZonedDateTime ，使用区域ID获取偏移量。
    
    当转换回ZonedDateTime时，如果本地日期时间处于重叠状态，则可能会保留偏移量，否则将使用较早的偏移量。如果有差距，当地的日期时间将按差距的长短进行调整。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    days - 添加的日子可能为负数
    
    结果
    
    一个 ZonedDateTime基于这个日期时间与添加的天数，不为null
    
    异常
    
    DateTimeException - 如果结果超出支持的日期范围
  - plusHours
```
public ZonedDateTime plusHours(long hours)
```
    返回此ZonedDateTime的副本，其指定时间以小时为单位。
    这将在即时的时间线上运行，这样添加一个小时将始终是一个小时之后的持续时间。这可能导致本地日期时间改变一个小时以外的数量。请注意，这是与日，月，年使用的不同的方法，因此添加一天与添加24小时不同。
    
    例如，考虑弹簧DST切换意味着本地时间01:00至01:59发生两次从偏移+02：00到+01：00两次的时区。
    - 增加一个小时00：30 + 02：00将导致01：30 + 02：00
    - 在01：30 + 02：00加1小时将会在01：30 + 01：00
    - 在01：30 + 01：00加1小时将会在02：30 + 01：00
    - 增加三个小时到00：30 + 02：00将导致02：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基于这个日期时间添加的秒，不为null
    
    异常
    
    DateTimeException - 如果结果超出支持的日期范围
  - plusNanos
```
public ZonedDateTime plusNanos(long nanos)
```
    返回此ZonedDateTime的副本，其指定时间以纳秒为单位。
    这在即时时间线上运行，使得添加一个纳米将始终是一纳秒的持续时间。这可能导致本地日期时间改变不是一个纳米的数量。请注意，这是与日，月，年使用的不同的方法。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    nanos - nanos添加，可能是负的
    
    结果
    
    一个 ZonedDateTime基于这个日期时间加上纳秒，不为null
    
    异常
    
    DateTimeException - 如果结果超出支持的日期范围
  - minus
```
public ZonedDateTime minus(TemporalAmount amountToSubtract)
```
    返回此日期时间的副本，并减去指定的金额。
    这将返回一个ZonedDateTime ，基于此，减去指定的数量。量通常是Period或Duration ，而可以是任何其他类型的实现TemporalAmount接口。
    
    通过调用TemporalAmount.subtractFrom(Temporal)将计算委托给金额对象。数量执行可以以任何方式实现减法，但是它通常会回调到minus(long, TemporalUnit) 。请参阅数量实施的文档，以确定是否可以成功减去它们。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    minus中的 ChronoZonedDateTime<LocalDate>
    
    Specified by:
    
    minus在界面 Temporal
    
    参数
    
    amountToSubtract - 减去量，不为空
    
    结果
    
    一个 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) ，其数量被否定。请参阅该方法，以了解如何添加，从而减去运算。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    minus在界面 ChronoZonedDateTime<LocalDate>
    
    Specified by:
    
    minus中的 Temporal
    
    参数
    
    amountToSubtract - 从结果中减去单位的数量可能为负数
    
    unit - 减去量的单位，不为空
    
    结果
    
    一个 ZonedDateTime基于此日期时间减去指定的数量，不为null
    
    异常
    
    DateTimeException - 如果不能进行减法
    
    UnsupportedTemporalTypeException - 如果不支持本机
    
    ArithmeticException - 如果发生数字溢出
  - minusYears
```
public ZonedDateTime minusYears(long years)
```
    返回此ZonedDateTime的副本，以减去的年份为单位。
    这将按当地时间线subtracting years运行到当地的日期。然后将其转换回ZonedDateTime ，使用区域ID获取偏移量。
    
    当转换回ZonedDateTime时，如果本地日期时间处于重叠状态，则可能会保留偏移量，否则将使用较早的偏移量。如果有差距，当地的日期时间将按差距的长短进行调整。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    years - 减去年份，可能为负数
    
    结果
    
    一个 ZonedDateTime基于这个日期时间与减去的年份，不为null
    
    异常
    
    DateTimeException - 如果结果超出了支持的日期范围
  - minusMonths
```
public ZonedDateTime minusMonths(long months)
```
    返回此ZonedDateTime的副本，其中指定的时间以月为单位减去。
    这在当地的时间线subtracting months运行到当地的日期。然后将其转换回ZonedDateTime ，使用区域ID获取偏移量。
    
    当转换回ZonedDateTime时，如果本地日期时间重叠，则可能会保留偏移量，否则将使用较早的偏移量。如果有差距，当地的日期时间将按差距的长短进行调整。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    months - 减去的月份，可能为负数
    
    结果
    
    一个 ZonedDateTime基于这个日期时间与减去的月份，不为null
    
    异常
    
    DateTimeException - 如果结果超出支持的日期范围
  - minusWeeks
```
public ZonedDateTime minusWeeks(long weeks)
```
    返回此ZonedDateTime的副本，其中指定的周期以星期为单位减去。
    这将按当地时间线subtracting weeks运行到当地的日期。然后将其转换回ZonedDateTime ，使用区域ID获取偏移量。
    
    当转换回ZonedDateTime时，如果本地日期时间重叠，则可能会保留偏移量，否则将使用较早的偏移量。如果有差距，当地的日期时间将按差距的长短进行调整。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    weeks - 减去星期，可能为负数
    
    结果
    
    一个 ZonedDateTime基于这个日期时间与减去的星期，不为null
    
    异常
    
    DateTimeException - 如果结果超出支持的日期范围
  - minusDays
```
public ZonedDateTime minusDays(long days)
```
    返回此ZonedDateTime的副本，其中指定的时间间隔以天减去。
    这将在当地的时间线subtracting days运行到当地的日期。然后将其转换回ZonedDateTime ，使用区域ID获取偏移量。
    
    当转换回ZonedDateTime时，如果本地日期时间处于重叠状态，则可能会保留偏移量，否则将使用较早的偏移量。如果有差距，当地的日期时间将按差距的长短进行调整。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    days - 减去的日子可能是负数
    
    结果
    
    一个 ZonedDateTime基于这个日期时间 ZonedDateTime的日期，不为null
    
    异常
    
    DateTimeException - 如果结果超出支持的日期范围
  - minusHours
```
public ZonedDateTime minusHours(long hours)
```
    返回此ZonedDateTime的副本，其中指定的时间以小时为单位减去。
    这在即时时间线上运行，使得减去一小时将始终是一小时前的持续时间。这可能导致本地日期时间改变一个小时以外的数量。请注意，这是与日，月，年使用的不同的方法，因此减去一天与添加24小时不同。
    
    例如，考虑弹簧DST切换意味着本地时间01:00至01:59发生两次从偏移+02：00到+01：00两次的时区。
    - 从02：30 + 01：00减去一个小时将导致01：30 + 02：00
    - 从01：30 + 01：00减去一小时将会导致01：30 + 02：00
    - 从01：30 + 02：00减去一个小时将导致00：30 + 01：00
    - 从02：30 + 01：00减去三个小时将导致00：30 + 02：00
    此实例是不可变的，不受此方法调用的影响。
    参数
    
    hours - 减去的时间可能为负数
    
    结果
    
    一个 ZonedDateTime基于这个日期时间减去小时，不为空
    
    异常
    
    DateTimeException - 如果结果超出了支持的日期范围
  - minusMinutes
```
public ZonedDateTime minusMinutes(long minutes)
```
    返回此ZonedDateTime的副本，其中指定的时间间隔以分钟为单位。
    这在即时时间线上运行，使得减去一分钟将始终是一分钟前的持续时间。这可能导致本地日期时间改变一分钟以外的数量。请注意，这是与日，月，年使用的不同的方法。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    minutes - 减去的 minutes可能为负数
    
    结果
    
    一个 ZonedDateTime基于这个日期时间减去分钟，不为空
    
    异常
    
    DateTimeException - 如果结果超出支持的日期范围
  - minusSeconds
```
public ZonedDateTime minusSeconds(long seconds)
```
    返回此ZonedDateTime的副本，其中指定的时间间隔以秒为单位。
    这在即时时间线上操作，使得减去一秒将始终是早一秒的持续时间。这可能导致本地日期时间改变一秒以外的数量。请注意，这是与日，月，年使用的不同的方法。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    seconds - 减去的秒数可能为负数
    
    结果
    
    一个 ZonedDateTime基于此日期时间减去秒，不为空
    
    异常
    
    DateTimeException - 如果结果超出支持的日期范围
  - minusNanos
```
public ZonedDateTime minusNanos(long nanos)
```
    返回这个ZonedDateTime的副本，以指定的时间减去纳秒。
    这在即时时间线上操作，使得减去一个纳米将始终是一个纳米的持续时间。这可能导致本地日期时间改变不是一个纳米的数量。请注意，这是与日，月，年使用的不同的方法。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    nanos - nanos减去，可能是负数
    
    结果
    
    一个 ZonedDateTime基于这个日期时间减去纳秒，不为空
    
    异常
    
    DateTimeException - 如果结果超出支持的日期范围
  - query
```
public <R> R query(TemporalQuery<R> query)
```
    使用指定的查询查询此日期时间。
    这将使用指定的查询策略对象查询此日期时间。 TemporalQuery对象定义了用于获取结果的逻辑。阅读查询的文档，以了解该方法的结果。
    
    该方法的结果是通过调用TemporalQuery.queryFrom(TemporalAccessor)方法，通过this作为参数的指定查询。
    
    Specified by:
    
    query在接口 ChronoZonedDateTime<LocalDate>
    
    Specified by:
    
    query在接口 TemporalAccessor
    
    参数类型
    
    R - 结果的类型
    
    参数
    
    query - 要调用的查询，不为空
    
    结果
    
    查询结果可能返回null（由查询定义）
    
    异常
    
    DateTimeException - 如果无法查询（由查询定义）
    
    ArithmeticException - 如果发生数字溢出（由查询定义）
  - until
```
public long until(Temporal endExclusive,
                  TemporalUnit unit)
```
    根据指定的单位计算到另一个日期时间的时间量。
    这可以计算两个ZonedDateTime对象之间的时间量，单位为TemporalUnit 。起点和终点是this和指定的日期时间。如果结束在开始之前，结果将为负数。例如，可以使用startDateTime.until(endDateTime, DAYS)两个日期时间之间的时间startDateTime.until(endDateTime, DAYS) 。
    
    所述Temporal传递给此方法被转换为ZonedDateTime使用from(TemporalAccessor) 。如果两个划分的日期时间之间的时区不同，则指定的结束日期时间被标准化为与此日期时间相同的区域。
    
    计算返回一个整数，表示两个日期时间之间的完整单位数。例如，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 ，那么这个方法的结果是通过调用this作为第一个参数通过this获得的， TemporalUnit.between(Temporal, Temporal)后的输入是时间作为第二个参数。
    
    此实例是不可变的，不受此方法调用的影响。
    Specified by:
    
    until在接口 Temporal
    
    参数
    
    endExclusive - 结束日期，排他，转换为 ZonedDateTime ，不为空
    
    unit - 衡量金额的单位，不为空
    
    结果
    
    在此日期和结束日期时间之间的时间量
    
    异常
    
    DateTimeException - 如果不能计算金额，或者结束时间不能转换为 ZonedDateTime
    
    UnsupportedTemporalTypeException - 如果不支持本机
    
    ArithmeticException - 如果发生数字溢出
  - format
```
public String format(DateTimeFormatter formatter)
```
    使用指定的格式化程序格式化此日期时间。
    这个日期时间将传递给格式化程序以生成一个字符串。
    
    Specified by:
    
    format中的 ChronoZonedDateTime<LocalDate>
    
    参数
    
    formatter - 要使用的格式化程序，不为null
    
    结果
    
    格式化的日期时间字符串，不为空
    
    异常
    
    DateTimeException - 打印时是否发生错误
  - toOffsetDateTime
```
public OffsetDateTime toOffsetDateTime()
```
    将此日期时间转换为OffsetDateTime 。
    这将使用本地日期时间和偏移量创建偏移日期时间。区域ID被忽略。
    
    结果
    
    表示相同本地日期时间和偏移量的偏移日期时间，不为空
  - equals
```
public boolean equals(Object obj)
```
    检查这个日期时间是否等于另一个日期时间。
    比较是基于偏移日期时间和区域。只有ZonedDateTime类型的ZonedDateTime被比较，其他类型返回false。
    
    Specified by:
    
    equals中的 ChronoZonedDateTime<LocalDate>
    
    重写：
    
    equals在 Object
    
    参数
    
    obj - 要检查的对象，null返回false
    
    结果
    
    如果这等于其他日期时间，则为true
    
    另请参见：
    
    Object.hashCode() ， HashMap
  - hashCode
```
public int hashCode()
```
    这个日期时间的哈希码。
    
    Specified by:
    
    hashCode在接口 ChronoZonedDateTime<LocalDate>
    
    重写：
    
    hashCode在 Object
    
    结果
    
    一个合适的哈希码
    
    另请参见：
    
    Object.equals(java.lang.Object) ， System.identityHashCode(java.lang.Object)
  - toString
```
public String toString()
```
    将此日期时间输出为String ，例如2007-12-03T10:15:30+01:00[Europe/Paris] 。
    格式由LocalDateTime组成，其次是ZoneOffset 。如果ZoneId与偏移量不相同，则输出ID。如果偏移量和ID相同，输出与ISO-8601兼容。
    
    Specified by:
    
    toString中的 ChronoZonedDateTime<LocalDate>
    
    重写：
    
    toString在 Object
    
    结果
    
    此日期时间的字符串表示形式，不为null

Class ZonedDateTime

方法摘要

Methods inherited from class java.lang.Object

Methods inherited from interface java.time.chrono.ChronoZonedDateTime

方法详细信息

now

now

now

of

of

of

ofLocal

ofInstant

ofInstant

ofStrict

from

parse

parse

isSupported

isSupported

range

get

getLong

getOffset

withEarlierOffsetAtOverlap

withLaterOffsetAtOverlap

getZone

withZoneSameLocal

withZoneSameInstant

withFixedOffsetZone

toLocalDateTime

toLocalDate

getYear

getMonthValue

getMonth

getDayOfMonth

getDayOfYear

getDayOfWeek

toLocalTime

getHour

getMinute

getSecond

getNano

with

with

withYear

withMonth

withDayOfMonth

withDayOfYear

withHour

withMinute

withSecond

withNano

truncatedTo

plus

plus

plusYears

plusMonths

plusWeeks

plusDays

plusHours

plusMinutes

plusSeconds

plusNanos

minus

minus

minusYears

minusMonths

minusWeeks

minusDays

minusHours

minusMinutes

minusSeconds

minusNanos

query

until

format

toOffsetDateTime

equals

hashCode