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-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代表。

两条时间线之间的转换是通过rules从ZoneId访问计算偏移。获得一个即时的偏移是简单的，因为有一个有效的偏移量为每一个瞬间。相比之下，获取本地日期时间的偏移不简单。有三例：
- 正常，有一个有效的偏移量。对于一年中的绝大多数情况，正常情况下应用，在本地日期时间有一个有效的偏移量。
- 与零有效偏移量的间隙。这是当时钟跳跃通常是由于春天的日光节约从“冬天”到“夏天”的变化。在一个间隙中有本地日期时间值，没有有效的偏移量。
- 重叠，有两个有效的偏移量。这是当时钟设置通常是由于秋季夏储蓄从“夏天”到“冬天”的变化。在重叠中，有两个有效的偏移量的本地日期时间值。
通过获取偏移量直接或隐式地将偏移量直接或隐式地转换到一个即时的任何方法都有可能是复杂的。

对于差距，一般的策略是，如果本地日期时间下降在中间的差距，那么由此产生的划时代的时间将有一个本地日期时间移向前的差距，导致在一个日期时间在后来的偏移量，通常是“夏季”时间。

对于重叠，一般的策略是，如果本地日期时间下降在中间的重叠，那么以前的偏移将被保留。如果没有以前的偏移，或以前的偏移是无效的，那么早期的偏移是使用，通常是“夏天”的时间。两个额外的方法，withEarlierOffsetAtOverlap()和withLaterOffsetAtOverlap()，帮助管理一个重叠的情况。

在设计方面，这类应该被看作主要是一个LocalDateTime和ZoneId组合。是一个重要的ZoneOffset，但中等，资料片，用来确保类代表一个瞬间，尤其是在夏令时的重叠。

这是一个value-based类；利用身份敏感的操作（包括引用相等（==），身份的哈希代码，或同步）的实例ZonedDateTime可能有不可预知的结果应该是可以避免的。的equals法进行比较。
实现要求：

一个国家 ZonedDateTime持有相当于三个独立的物体，一个 LocalDateTime，一 ZoneId和解决 ZoneOffset。偏移和本地日期时间用于在必要时定义一个即时。区域标识用于获取偏移量更改时的规则和何时使用该规则。偏移量不能自由设置，因为区域控制偏移是有效的。
这个类是不可变的和线程安全的。

从以下版本开始：

一点八

另请参见：

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`	`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`	`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)` 获得 `ZonedDateTime`实例从一个 `Instant`。
`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)` 获得 `ZonedDateTime`实例从一个文本字符串，如 `2007-12-03T10:15:30+01:00[Europe/Paris]`。
`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`与定时。
`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()` 将此日期时间的副本与区域标识设置为偏移量，返回一个。
`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 -时钟使用，不为空
    
    结果
    
    当前日期时间，而不是空
  - of
```
public static ZonedDateTime of(LocalDate date,
                               LocalTime time,
                               ZoneId zone)
```
    获得 ZonedDateTime实例从本地日期和时间。
    这将创建一个分区的日期时间，以尽可能紧密地匹配输入的本地日期和时间。时间区域规则，如日光节约，意味着不是每个本地日期时间都是有效的指定区域，因此本地日期时间可以调整。
    
    本地日期时间和第一次合并，以形成一个本地日期时间。本地日期时间，然后解决到时间线上的一个单一的即时。这是通过寻找从UTC /格林尼治本地日期时间的区域ID。rules定义有效的抵消了
    
    在大多数情况下，只有一个本地日期时间的有效偏移量。在重叠的情况下，当时钟被设置回来时，有两个有效的偏移量。此方法使用较早的偏移量，通常对应于“夏季”。
    
    在一个差距的情况下，当时钟跳向前时，没有有效的偏移量。相反，本地日期时间被调整为稍后的差距的长度。对于一个典型的一小时的日光节约变化，当地日期时间将移动一个小时后到偏移通常对应于“夏天”。
    
    参数
    
    date -本地日期，不为空
    
    time -当地时间，不空
    
    zone的时区，不空
    
    结果
    
    偏移日期时间，而不是空
  - of
```
public static ZonedDateTime of(LocalDateTime localDateTime,
                               ZoneId zone)
```
    获得 ZonedDateTime实例从本地日期时间。
    这将创建一个分区日期时间，以尽可能紧密地匹配输入本地日期时间。时间区域规则，如日光节约，意味着不是每个本地日期时间都是有效的指定区域，因此本地日期时间可以调整。
    
    本地日期时间解决在时间线上的一个单一时刻上。这是通过寻找从UTC /格林尼治本地日期时间的区域ID。rules定义有效的抵消了
    
    在大多数情况下，只有一个本地日期时间的有效偏移量。在重叠的情况下，当时钟被设置回来时，有两个有效的偏移量。此方法使用较早的偏移量，通常对应于“夏季”。
    
    在一个差距的情况下，当时钟跳向前时，没有有效的偏移量。相反，本地日期时间被调整为稍后的差距的长度。对于一个典型的一小时的日光节约变化，当地日期时间将移动一个小时后到偏移通常对应于“夏天”。
    
    参数
    
    localDateTime -本地日期时间，不空
    
    zone的时区，不空
    
    结果
    
    分区日期时间，而不是空
  - of
```
public static ZonedDateTime of(int year,
                               int month,
                               int dayOfMonth,
                               int hour,
                               int minute,
                               int second,
                               int nanoOfSecond,
                               ZoneId zone)
```
    获得 ZonedDateTime实例从年，月，日，小时，分钟，秒，纳秒和时区。
    这将创建一个分区日期时间，以尽可能紧密地匹配七个指定字段的本地日期时间。时间区域规则，如日光节约，意味着不是每个本地日期时间都是有效的指定区域，因此本地日期时间可以调整。
    
    本地日期时间解决在时间线上的一个单一时刻上。这是通过寻找从UTC /格林尼治本地日期时间的区域ID。rules定义有效的抵消了
    
    在大多数情况下，只有一个本地日期时间的有效偏移量。在重叠的情况下，当时钟被设置回来时，有两个有效的偏移量。此方法使用较早的偏移量，通常对应于“夏季”。
    
    在一个差距的情况下，当时钟跳向前时，没有有效的偏移量。相反，本地日期时间被调整为稍后的差距的长度。对于一个典型的一小时的日光节约变化，当地日期时间将移动一个小时后到偏移通常对应于“夏天”。
    
    这种方法主要存在于编写测试用例的情况下。非测试代码通常会使用其他方法来创建一个偏移时间。LocalDateTime有五额外的便利以减少参数等效工厂方法的变种。他们没有在这里提供减少的足迹的原料药。
    
    参数
    
    year年的代表，从min_year到max_year
    
    month -年月为代表，从1（一月）到12（十二月）
    
    dayOfMonth -月代表天，从1到31
    
    hour -天代表小时，从0到23
    
    minute -小时代表分钟，从0到59
    
    second -二分为代表，从0到59
    
    nanoOfSecond -二代表纳米，从0到999999999
    
    zone的时区，不空
    
    结果
    
    偏移日期时间，而不是空
    
    异常
    
    DateTimeException -如果任何字段的值超出范围，或如果月日年月日是无效的
  - ofLocal
```
public static ZonedDateTime ofLocal(LocalDateTime localDateTime,
                                    ZoneId zone,
                                    ZoneOffset preferredOffset)
```
    获得 ZonedDateTime实例从使用首选本地日期时间如果可能抵消。
    本地日期时间解决在时间线上的一个单一时刻上。这是通过寻找从UTC /格林尼治本地日期时间的区域ID。rules定义有效的抵消了
    
    在大多数情况下，只有一个本地日期时间的有效偏移量。在重叠的情况下，时钟被设置回来，有两个有效的偏移量。如果首选的偏移量是有效的偏移量之一，那么它就被使用了。否则早期有效的偏移量被使用，通常对应于“夏季”。
    
    在一个差距的情况下，时钟跳向前，没有有效的偏移。相反，本地日期时间被调整为稍后的差距的长度。对于一个典型的一小时的日光节约变化，当地日期时间将移动一个小时后到偏移通常对应于“夏天”。
    
    参数
    
    localDateTime -本地日期时间，不空
    
    zone的时区，不空
    
    preferredOffset -区偏移，null，如果没有偏好
    
    结果
    
    分区日期时间，而不是空
  - ofInstant
```
public static ZonedDateTime ofInstant(Instant instant,
                                      ZoneId zone)
```
    获得 ZonedDateTime实例从一个 Instant。
    这将创建一个分区的时间与指定的相同的时间。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的时区，不空
    
    结果
    
    分区日期时间，而不是空
  - from
```
public static ZonedDateTime from(TemporalAccessor temporal)
```
    获得 ZonedDateTime实例从一个时空对象。
    这将获得一个分区的日期时间为基础的指定的时间。一个TemporalAccessor表示日期和时间信息，任意设置，本厂将以ZonedDateTime实例。
    
    转换将首先从时态对象获得ZoneId，回落到一个ZoneOffset如果必要。然后它会试图获得一个Instant，回落到LocalDateTime如果必要。结果将是结合ZoneId或ZoneOffset与Instant或LocalDateTime。实现允许执行优化，如访问这些字段，这些字段相当于相关对象。
    
    这种方法相匹配的功能接口TemporalQuery可以通过方法引用查询中的签名，ZonedDateTime::from。
    
    Specified by:
    
    from 接口 ChronoZonedDateTime<LocalDate>
    
    参数
    
    temporal -转换时间的对象，不为空
    
    结果
    
    分区日期时间，而不是空
    
    异常
    
    DateTimeException如果无法转换到一个 ZonedDateTime
    
    另请参见：
    
    Chronology.zonedDateTime(TemporalAccessor)
  - parse
```
public static ZonedDateTime parse(CharSequence text)
```
    获得 ZonedDateTime实例从一个文本字符串，如 2007-12-03T10:15:30+01:00[Europe/Paris]。
    该字符串必须是一个有效的日期时间和使用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，然后通过调用作为参数传递this TemporalField.isSupportedBy(TemporalAccessor)得到此方法的结果。是否支持字段由字段确定。
    Specified by:
    
    isSupported 接口 ChronoZonedDateTime<LocalDate>
    
    Specified by:
    
    isSupported 接口 TemporalAccessor
    
    参数
    
    field -现场检查null返回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，然后通过调用作为参数传递this TemporalUnit.isSupportedBy(Temporal)得到此方法的结果。是否支持单位是由单位确定的。
    Specified by:
    
    isSupported 接口 ChronoZonedDateTime<LocalDate>
    
    Specified by:
    
    isSupported 接口 Temporal
    
    参数
    
    unit -检查单元，空返回false
    
    结果
    
    如果单位可以增加/减去，如果没有的话
  - range
```
public ValueRange range(TemporalField field)
```
    获取指定字段的有效值的范围。
    该范围对象表示字段的最小值和最大有效值。此日期时间用于提高返回范围的准确性。如果它是不可能返回的范围，因为字段不支持或其他一些原因，抛出一个异常。
    
    如果该字段是ChronoField然后查询执行。的supported fields将返回适当的范围的情况下。所有其他ChronoField实例将抛出一个UnsupportedTemporalTypeException。
    
    如果该字段是不是ChronoField，然后通过调用作为参数传递this TemporalField.rangeRefinedBy(TemporalAccessor)得到此方法的结果。是否可以得到范围是由字段确定的。
    
    Specified by:
    
    range 接口 ChronoZonedDateTime<LocalDate>
    
    Specified by:
    
    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、扔DateTimeException。所有其他ChronoField实例将抛出一个UnsupportedTemporalTypeException。
    
    如果该字段是不是ChronoField，然后通过调用作为参数传递this TemporalField.getFrom(TemporalAccessor)得到此方法的结果。是否可以得到值，以及值表示的值，由字段确定。
    
    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，然后通过调用作为参数传递this TemporalField.getFrom(TemporalAccessor)得到此方法的结果。是否可以得到值，以及值表示的值，由字段确定。
    
    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为主，不为空
  - withLaterOffsetAtOverlap
```
public ZonedDateTime withLaterOffsetAtOverlap()
```
    返回此日期时间更改区域的副本，以在本地时间线重叠中的两个有效偏移量的后面偏移。
    这种方法只有什么影响时，当地的时间线重叠，如在一个秋天的日光节约割接。在这种情况下，本地日期时间有两个有效的偏移量。调用此方法将返回一个分区的时间与后面的两个选定的。
    
    如果这个方法被调用时，它是不重叠的，this返回。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    withLaterOffsetAtOverlap 接口 ChronoZonedDateTime<LocalDate>
    
    结果
    
    与后来的偏移对这个日期时间 ZonedDateTime为主，不为空
  - getZone
```
public ZoneId getZone()
```
    获取时间区域，如“欧洲/巴黎”。
    返回ID标识时区的rules区域，确定何时以及如何从UTC偏移/格林尼治的变化。
    
    区域ID可以同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日期时间与请求的区域，不为空
  - withZoneSameInstant
```
public ZonedDateTime withZoneSameInstant(ZoneId zone)
```
    返回此日期时间的副本，以不同的时区，保留即时。
    这种方法改变了时区并保留了即时。这通常会导致本地日期时间的更改。
    
    此方法是基于保持相同的瞬间，从而在本地时间线的差距和重叠，对结果没有影响。
    
    在维持当地时间变化的偏移，使用withZoneSameLocal(ZoneId)。
    
    Specified by:
    
    withZoneSameInstant 接口 ChronoZonedDateTime<LocalDate>
    
    参数
    
    zone -时区改变，不为空
    
    结果
    
    基于这一 ZonedDateTime日期时间与请求的区域，不为空
    
    异常
    
    DateTimeException -如果结果超过支持的日期范围
  - withFixedOffsetZone
```
public ZonedDateTime withFixedOffsetZone()
```
    将此日期时间的副本与区域标识设置为偏移量，返回一个。
    这将返回一个日期时间，划区域ID为getOffset()相同。本地日期时间、偏移量和结果的即时性与此日期时间相同。
    
    将日期时间设置为一个固定的单偏移量意味着任何未来的计算，如加法或减法，没有复杂的边缘情况下，由于时区规则。这也可能是有用的在发送一个分区的日期时间在网络上，大部分的协议，如ISO-8601，只处理偏移，而不是基于区域的区域入侵检测系统。
    
    这相当于ZonedDateTime.of(zdt.toLocalDateTime(), zdt.getOffset())。
    
    结果
    
    一个设置偏移的区域ID ZonedDateTime，不空
  - toLocalDateTime
```
public LocalDateTime toLocalDateTime()
```
    获取此日期时间的 LocalDateTime部分。
    这将返回一个具有相同的年、月LocalDateTime，日期和时间日期时间。
    
    Specified by:
    
    toLocalDateTime 接口 ChronoZonedDateTime<LocalDate>
    
    结果
    
    此日期时间的本地日期时间部分，而不是空
  - toLocalDate
```
public LocalDate toLocalDate()
```
    获取此日期时间的 LocalDate部分。
    这将返回一个与当年LocalDate，月日这个日期时间。
    
    Specified by:
    
    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。应用程序代码经常清楚如果枚举Month是通过调用getMonth()使用。
    
    结果
    
    一年中的一个月，从1到12
    
    另请参见：
    
    getMonth()
  - getMonth
```
public Month getMonth()
```
    得到月年田间使用 Month枚举。
    此方法返回的枚举Month月。这避免了混乱是什么int平均值。如果你需要访问原始int值然后枚举提供int value。
    
    结果
    
    一年中的一个月，而不是零
    
    另请参见：
    
    getMonthValue()
  - 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，二和纳秒这个日期时间。
    
    Specified by:
    
    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到999999999
  - with
```
public ZonedDateTime with(TemporalAdjuster adjuster)
```
    返回此日期时间的调整副本。
    这将返回一个ZonedDateTime，基于此，与日期时间调整。调整使用指定的调整器策略对象。阅读调整器的文档，了解将要做什么调整。
    
    一个简单的调节器可以简单地设置一个字段，例如年字段。一个更复杂的调节器可能会把日期定在月的最后一天。选择常见的调整提供了TemporalAdjuster。这些包括找到“一个月的最后一天”和“下星期三”。关键日期时间类也实现TemporalAdjuster接口，如Month和MonthDay。该调节器是负责处理特殊情况下，如不同长度的月和跳跃年。
    
    例如，此代码在七月的最后一天返回日期：
```
进口静态java。时间。月。*；进口静态java。时间。时间。调节。*；结果：zoneddatetime，（七月），（lastdayofmonth()）；
```
    这类LocalDate和LocalTime实施TemporalAdjuster，因此该方法可用于更改日期、时间或偏移：
```
结果：zoneddatetime与（日期）；结果：zoneddatetime与（时间）；
```
    ZoneOffset还实现了TemporalAdjuster然而使用它作为一个参数通常没有效果。一个ZonedDateTime偏移量是由时区控制为主。因此，改变偏移量一般不具有意义，因为只有一个有效的偏移量为本地日期时间和区域。如果分区日期时间是在日光储蓄重叠，那么偏移是用来切换两个有效的偏移量之间的。在所有其他情况下，偏移量将被忽略。
    
    这种方法的结果是通过调用指定的调节器，通过this作为论据的TemporalAdjuster.adjustInto(Temporal)方法得到的。
    
    此实例是不可变的，不受此方法调用的影响。
    Specified by:
    
    with 接口 ChronoZonedDateTime<LocalDate>
    
    Specified by:
    
    with 接口 Temporal
    
    参数
    
    adjuster -调节器使用，不为空
    
    结果
    
    一个 ZonedDateTime基于调整 this，不空
    
    异常
    
    DateTimeException -如果调整不能
    
    ArithmeticException如果数值溢出时
  - with
```
public ZonedDateTime with(TemporalField field,
                          long newValue)
```
    将此日期时间的副本与指定的字段设置为一个新值。
    这将返回一个ZonedDateTime，在此基础上，对指定字段的值的变化。这可以用来改变任何支持的领域，如一年，一个月或一天的月。如果不可能设置值，因为字段不支持或其他原因，则抛出异常。
    
    在某些情况下，更改指定的字段会导致结果的日期时间无效，如更改从1月31日至二月的月将使月无效的日期无效。在这样的情况下，该字段是负责解决日期。通常情况下，它会选择以前的有效日期，这将是二月的最后一个有效的一天，在这个例子中。
    
    如果该字段是ChronoField然后调整在这里实现。
    
    的INSTANT_SECONDS场将返回与指定的即时日期时间。第二区域和第二纳米是不变的。结果将有一个偏移来自新的即时和原始区。如果新的即时值超出有效范围，则会抛出DateTimeException。
    
    的OFFSET_SECONDS场通常会被忽略。一个ZonedDateTime偏移量是由时区控制为主。因此，改变偏移量一般不具有意义，因为只有一个有效的偏移量为本地日期时间和区域。如果分区日期时间是在日光储蓄重叠，那么偏移是用来切换两个有效的偏移量之间的。在所有其他情况下，偏移量将被忽略。如果新的偏移值超出有效范围，则会抛出DateTimeException。
    
    另supported fields将表现为每个匹配的方法LocalDateTime。该区域不是计算的一部分，将保持不变。当转换回ZonedDateTime，如果当地的日期时间是重叠的，那么偏移将被保留，如果可能的话，否则将使用较早的偏移。如果在一个差距，本地日期时间将被调整的差距的长度。
    
    所有其他ChronoField实例将抛出一个UnsupportedTemporalTypeException。
    
    如果该字段是不是ChronoField，然后通过调用作为参数传递this TemporalField.adjustInto(Temporal, long)得到此方法的结果。在这种情况下，字段决定是否以及如何调整即时。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    with 接口 ChronoZonedDateTime<LocalDate>
    
    Specified by:
    
    with 接口 Temporal
    
    参数
    
    field -现场设置的结果，不为空
    
    newValue -场的结果中的新价值
    
    结果
    
    一个 ZonedDateTime基于指定的字段集 this，不空
    
    异常
    
    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（十二月）
    
    结果
    
    基于这一 ZonedDateTime日期时间与请求的月，不为空
    
    异常
    
    DateTimeException如果年值月是无效的
  - withDayOfMonth
```
public ZonedDateTime withDayOfMonth(int dayOfMonth)
```
    返回一份本 ZonedDateTime与天月值改变。
    这是当地时间，当地的时间changing the day-of-month。这是然后转换回一个ZonedDateTime，用区域ID获取偏移。
    
    当转换回ZonedDateTime，如果当地的日期时间是重叠的，那么偏移将被保留，如果可能的话，否则将使用较早的偏移。如果在一个差距，本地日期时间将被调整的差距的长度。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    dayOfMonth -月在结果集的一天，从1至28
    
    结果
    
    基于这一 ZonedDateTime日期时间与请求的天，不是空的
    
    异常
    
    DateTimeException如果月值一天是无效的，或者如果月日年月日是无效的
  - withDayOfYear
```
public ZonedDateTime withDayOfYear(int dayOfYear)
```
    返回一份本 ZonedDateTime与天的年变化。
    这是当地时间，当地的时间changing the day-of-year。这是然后转换回一个ZonedDateTime，用区域ID获取偏移。
    
    当转换回ZonedDateTime，如果当地的日期时间是重叠的，那么偏移将被保留，如果可能的话，否则将使用较早的偏移。如果在一个差距，本地日期时间将被调整的差距的长度。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    dayOfYear -一年建立在结果的那一天，从1到杂志
    
    结果
    
    与请求日这一天 ZonedDateTime为主，不为空
    
    异常
    
    DateTimeException如果年值一天是无效的，或者如果一天今年是无效的
  - withHour
```
public ZonedDateTime withHour(int hour)
```
    返回一份本 ZonedDateTime与一个值改变。
    这是当地时间，当地的时间changing the time。这是然后转换回一个ZonedDateTime，用区域ID获取偏移。
    
    当转换回ZonedDateTime，如果当地的日期时间是重叠的，那么偏移将被保留，如果可能的话，否则将使用较早的偏移。如果在一个差距，本地日期时间将被调整的差距的长度。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    hour -天在结果集时，从0到23
    
    结果
    
    基于这一 ZonedDateTime日期时间与请求的时辰，不空
    
    异常
    
    DateTimeException -如果时间值无效
  - withMinute
```
public ZonedDateTime withMinute(int minute)
```
    返回一份本 ZonedDateTime与分钟小时值改变。
    这是当地时间，当地的时间changing the time。这是然后转换回一个ZonedDateTime，用区域ID获取偏移。
    
    当转换回ZonedDateTime，如果当地的日期时间是重叠的，那么偏移将被保留，如果可能的话，否则将使用较早的偏移。如果在一个差距，本地日期时间将被调整的差距的长度。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    minute -小时设置在结果的那一刻，从0到59
    
    结果
    
    基于这一 ZonedDateTime日期时间与请求的一分钟，不为空
    
    异常
    
    DateTimeException如果分钟值无效
  - withSecond
```
public ZonedDateTime withSecond(int second)
```
    返回一份本 ZonedDateTime第二分钟值改变。
    这是当地时间，当地的时间changing the time。这是然后转换回一个ZonedDateTime，用区域ID获取偏移。
    
    当转换回ZonedDateTime，如果当地的日期时间是重叠的，那么偏移将被保留，如果可能的话，否则将使用较早的偏移。如果在一个差距，本地日期时间将被调整的差距的长度。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    second -二分钟设置的结果，从0到59
    
    结果
    
    基于这一 ZonedDateTime日期时间与请求的第二，不空
    
    异常
    
    DateTimeException如果二值无效
  - withNano
```
public ZonedDateTime withNano(int nanoOfSecond)
```
    返回一份本 ZonedDateTime与纳米二值改变。
    这是当地时间，当地的时间changing the time。这是然后转换回一个ZonedDateTime，用区域ID获取偏移。
    
    当转换回ZonedDateTime，如果当地的日期时间是重叠的，那么偏移将被保留，如果可能的话，否则将使用较早的偏移。如果在一个差距，本地日期时间将被调整的差距的长度。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    nanoOfSecond -二设置结果纳米，从0到999999999
    
    结果
    
    基于这一 ZonedDateTime日期时间与请求的纳秒，不空
    
    异常
    
    DateTimeException如果纳米值无效
  - truncatedTo
```
public ZonedDateTime truncatedTo(TemporalUnit unit)
```
    返回一份本 ZonedDateTime与定时。
    截断返回原始日期时间的副本，该字段小于指定的单位设置为零的字段。例如，截断与minutes单元组分，第二场零纳米二。
    
    单位必须有一个duration分成标准节长度无余。这包括所有提供的时间单位ChronoUnit和DAYS。其他单位抛出一个异常。
    
    这是在当地时间线，truncating底层的本地日期时间。这是然后转换回一个ZonedDateTime，用区域ID获取偏移。
    
    当转换回ZonedDateTime，如果当地的日期时间是重叠的，那么偏移将被保留，如果可能的话，否则将使用较早的偏移。如果在一个差距，本地日期时间将被调整的差距的长度。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    unit -单位截形，不为空
    
    结果
    
    基于这一 ZonedDateTime日期时间与时间截断，不空
    
    异常
    
    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 -添加量，不为空
    
    结果
    
    基于这一 ZonedDateTime日期时间的增加，不为空
    
    异常
    
    DateTimeException如果还不能
    
    ArithmeticException如果数值溢出时
  - plus
```
public ZonedDateTime plus(long amountToAdd,
                          TemporalUnit unit)
```
    返回此日期时间的副本，添加指定的金额。
    这将返回一个ZonedDateTime，基于此，在单元的添加量。如果它是不可能添加的量，因为该单元不支持或其他原因，则抛出异常。
    
    如果该字段是ChronoUnit然后添加在这里实现。该区域不是计算的一部分，在结果中会保持不变。日期和时间单位的计算不同。
    
    日期单位操作在本地时间线。期间第一次添加到本地日期时间，然后转换回划日期时间用区域ID转换使用ofLocal(LocalDateTime, ZoneId, ZoneOffset)之前添加偏移。
    
    时间单位操作的即时时间线。期间第一次添加到本地日期时间，然后转换回划日期时间用区域ID转换使用ofInstant(LocalDateTime, ZoneOffset, ZoneId)之前添加偏移。
    
    如果该字段是不是ChronoUnit，然后通过调用作为参数传递this TemporalUnit.addTo(Temporal, long)得到此方法的结果。在这种情况下，该单元确定是否和如何执行加法。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    plus 接口 ChronoZonedDateTime<LocalDate>
    
    Specified by:
    
    plus 接口 Temporal
    
    参数
    
    amountToAdd -单位的数量增加的结果，可能是负面的
    
    unit -量的单位添加，不为空
    
    结果
    
    基于这一 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小时。
    
    例如，考虑一个时间区，春季DST割接意味着当地时间01:00到天使出现两次从偏移+ + 01:00 02:00。
    - 添加一个小时00:30 + 02:00将导致01:30 + 02:00
    - 添加一个小时01:30 + 02:00将导致01:30 + 01:00
    - 添加一个小时01:30 + 01:00将导致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日期时间用秒说，不空
    
    异常
    
    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)。咨询文档的量的实现，以确定它是否可以成功地减去。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    minus 接口 ChronoZonedDateTime<LocalDate>
    
    Specified by:
    
    minus 接口 Temporal
    
    参数
    
    amountToSubtract -减去的量，不为空
    
    结果
    
    基于这一 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)否定。见该方法充分说明了如何加法，从而减法，作品。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    minus 接口 ChronoZonedDateTime<LocalDate>
    
    Specified by:
    
    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小时。
    
    例如，考虑一个时间区，春季DST割接意味着当地时间01:00到天使出现两次从偏移+ + 01:00 02: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 -减分，可能是负面的
    
    结果
    
    基于这一 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对象定义了用来获得结果的逻辑。阅读查询的文档，了解该方法的结果将是什么。
    
    这种方法的结果是通过调用指定的查询通过this作为论据的TemporalQuery.queryFrom(TemporalAccessor)方法得到的。
    
    Specified by:
    
    query 接口 ChronoZonedDateTime<LocalDate>
    
    Specified by:
    
    query 接口 TemporalAccessor
    
    参数类型
    
    R -结果的类型
    
    参数
    
    query -调用查询，不空
    
    结果
    
    查询结果，可以返回（由查询所定义）
    
    异常
    
    DateTimeException如果无法查询（查询所定义）
    
    ArithmeticException如果数值溢出时（由查询定义）
  - until
```
public long until(Temporal endExclusive,
                  TemporalUnit unit)
```
    计算时间的量，直到指定单元的另一个日期时间。
    这两ZonedDateTime计算对象之间的时间量在一个TemporalUnit条款。开始和结束点this和指定的日期时间。结果将是负的，如果结束之前开始。例如，两个日期时间之间的时间可以计算startDateTime.until(endDateTime, DAYS)。
    
    的Temporal传递给此方法转换为ZonedDateTime使用from(TemporalAccessor)。如果时区在两个分区之间的时间段不同，则指定的结束日期时间与此日期时间的相同区域为有相同的区域。
    
    计算返回一个整数，表示两个日期之间的完整单元的数目。例如，在2012-06-15t00:00z和2012-08-14t23:59z之间月期只有一个月很短，两个月一分钟。
    
    使用这种方法有两个等效的方法。首先是调用这个方法。二是用TemporalUnit.between(Temporal, Temporal)：
```
这两条线是等价的金额=开始，直到（结束，月）；金额=月间（开始，结束）；
```
    的选择应基于使得代码更易读。
    计算中实现该方法ChronoUnit。单位NANOS，MICROS，MILLIS，SECONDS，MINUTES，HOURS和HALF_DAYS，DAYS，WEEKS，MONTHS，YEARS，DECADES，CENTURIES，MILLENNIA和ERAS支持。其他ChronoUnit值将抛出一个异常。
    
    日期和时间单位的计算不同。
    
    日期单位在本地时间线操作，使用本地日期时间。例如，从1日中午到中午的第二天的时间，总有一天会被计算为一天，不论是否有一个日光节约的变化或不。
    
    时间单位操作的即时时间线。计算有效地将两划日期时间瞬间与计算之间的时间段。例如，从中午1天到中午的第二天的时间可能是23，24或25小时（或一些其他金额），这取决于是否有日光节约的变化或不。
    
    如果单位不ChronoUnit，然后通过调用TemporalUnit.between(Temporal, Temporal) this作为第一个参数传递和转换的输入时间作为第二个参数给出了这个方法的结果。
    
    此实例是不可变的，不受此方法调用的影响。
    Specified by:
    
    until 接口 Temporal
    
    参数
    
    endExclusive -结束日期，排斥，这是转化为一个 ZonedDateTime，不空
    
    unit -单位量来衡量，不为空
    
    结果
    
    这个日期时间和结束日期时间之间的时间
    
    异常
    
    DateTimeException如果金额无法计算，或结束时间不能转换为 ZonedDateTime
    
    UnsupportedTemporalTypeException如果单位不支持
    
    ArithmeticException如果数值溢出时
  - format
```
public String format(DateTimeFormatter formatter)
```
    这个日期时间格式使用指定的格式化程序。
    这个日期将被传递到格式化程序产生一个字符串。
    
    Specified by:
    
    format 接口 ChronoZonedDateTime<LocalDate>
    
    参数
    
    formatter -格式化程序使用，不为空
    
    结果
    
    格式化的日期时间字符串，而不是空的
    
    异常
    
    DateTimeException如果打印时发生错误
  - toOffsetDateTime
```
public OffsetDateTime toOffsetDateTime()
```
    将这一 OffsetDateTime日期时间。
    这将创建一个偏移日期时间，使用本地日期时间和偏移量。忽略区域标识。
    
    结果
    
    偏移日期时间，表示相同的本地日期时间和偏移量，而不是空值
  - equals
```
public boolean equals(Object obj)
```
    检查此日期时间是否等于另一个日期时间。
    该比较是基于偏移日期时间和区域。ZonedDateTime型只有对象相比，其他类型返回false。
    
    Specified by:
    
    equals 接口 ChronoZonedDateTime<LocalDate>
    
    重写：
    
    equals 方法重写，继承类 Object
    
    参数
    
    obj -检查对象，空返回false
    
    结果
    
    如果这是等于另一日期时间
    
    另请参见：
    
    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
    
    结果
    
    这个日期时间的字符串表示，而不是空的

Submit a bug or feature
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
Copyright © 1993, 2014, Oracle and/or its affiliates. All rights reserved.

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