OffsetDateTime (Java Platform SE 8 )

java.lang.Object
- java.time.OffsetDateTime

All Implemented Interfaces:

Serializable ， Comparable < OffsetDateTime >， Temporal ， TemporalAccessor ， TemporalAdjuster
```
public final class OffsetDateTime
extends Object
implements Temporal, TemporalAdjuster, Comparable<OffsetDateTime>, Serializable
```
在ISO-8601日历系统中的UTC /格林威治偏移的日期时间，如2007-12-03T10:15:30+01:00 。
OffsetDateTime是具有偏移量的日期时间的不可变表示。该类存储所有日期和时间字段，精度为纳秒，以及与UTC /格林威治的偏移量。例如，值“2007年10月2日13：45.30.123456789 +02：00”可存储在OffsetDateTime 。

OffsetDateTime ， ZonedDateTime和Instant都存储在时间线瞬间纳秒的精度。 Instant是最简单的，只是代表瞬间。 OffsetDateTime增加了UTC /格林威治的偏移量，这样可以获得当地的日期时间。 ZonedDateTime添加了全时区规则。

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

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

实现要求：

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

从以下版本开始：

1.8

另请参见：

Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`static OffsetDateTime`	`MAX` 最大支持 `OffsetDateTime` ，'+ 999999999-12-31T23：59：59.999999999-18：00'。
`static OffsetDateTime`	`MIN` 最低支持 `OffsetDateTime` 999999999-01-01T00：00：00 + 18：00'。

方法摘要

所有方法静态方法接口方法具体的方法
Modifier and Type	Method and Description
`Temporal`	`adjustInto(Temporal temporal)` 调整指定的时间对象与此对象具有相同的偏移量，日期和时间。
`ZonedDateTime`	`atZoneSameInstant(ZoneId zone)` 将此日期时间与时区相结合，创建一个 `ZonedDateTime`确保结果具有相同的时刻。
`ZonedDateTime`	`atZoneSimilarLocal(ZoneId zone)` 将此日期时间与时区相结合，以创建一个 `ZonedDateTime`尝试保持相同的本地日期和时间。
`int`	`compareTo(OffsetDateTime other)` 将此 `OffsetDateTime`与另一个日期时间进行比较。
`boolean`	`equals(Object obj)` 检查这个日期时间是否等于另一个日期时间。
`String`	`format(DateTimeFormatter formatter)` 使用指定的格式化程序格式化此日期时间。
`static OffsetDateTime`	`from(TemporalAccessor temporal)` 从时间对象获取一个 `OffsetDateTime`的实例。
`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()` 获取年份字段。
`int`	`hashCode()` 这个日期时间的哈希码。
`boolean`	`isAfter(OffsetDateTime other)` 检查此日期时间是否在指定的日期时间之后。
`boolean`	`isBefore(OffsetDateTime other)` 检查此日期时间是否在指定的日期时间之前。
`boolean`	`isEqual(OffsetDateTime other)` 检查此日期时间的时间是否等于指定的日期时间。
`boolean`	`isSupported(TemporalField field)` 检查指定的字段是否受支持。
`boolean`	`isSupported(TemporalUnit unit)` 检查指定的单位是否受支持。
`OffsetDateTime`	`minus(long amountToSubtract, TemporalUnit unit)` 返回此日期时间的副本，并减去指定的金额。
`OffsetDateTime`	`minus(TemporalAmount amountToSubtract)` 返回此日期时间的副本，并减去指定的金额。
`OffsetDateTime`	`minusDays(long days)` 返回此 `OffsetDateTime`的副本，并以减去的天数返回指定的时间段。
`OffsetDateTime`	`minusHours(long hours)` 返回此 `OffsetDateTime`的副本，其中指定的时间以小时为单位减去。
`OffsetDateTime`	`minusMinutes(long minutes)` 以指定的时间段返回此 `OffsetDateTime`的副本，以分钟为单位。
`OffsetDateTime`	`minusMonths(long months)` 返回此 `OffsetDateTime`的副本，指定的时间以月为单位减去。
`OffsetDateTime`	`minusNanos(long nanos)` 返回该指定周期的副本（以 `OffsetDateTime`的纳秒为单位）OffsetDateTime。
`OffsetDateTime`	`minusSeconds(long seconds)` 以指定的时间段返回此 `OffsetDateTime`的副本，以秒为单位。
`OffsetDateTime`	`minusWeeks(long weeks)` 返回这个 `OffsetDateTime`一个副本，指定的周期以周为单位减去。
`OffsetDateTime`	`minusYears(long years)` 返回此 `OffsetDateTime`的副本，以减去的年份为单位。
`static OffsetDateTime`	`now()` 从默认时区的系统时钟获取当前的日期时间。
`static OffsetDateTime`	`now(Clock clock)` 从指定的时钟获取当前的日期时间。
`static OffsetDateTime`	`now(ZoneId zone)` 从指定时区的系统时钟获取当前的日期时间。
`static OffsetDateTime`	`of(int year, int month, int dayOfMonth, int hour, int minute, int second, int nanoOfSecond, ZoneOffset offset)` 从一年，一个月，一天，一小时，一分钟，秒，纳秒和偏移中获取一个 `OffsetDateTime`的实例。
`static OffsetDateTime`	`of(LocalDate date, LocalTime time, ZoneOffset offset)` 从日期，时间和偏移量获取 `OffsetDateTime`的实例。
`static OffsetDateTime`	`of(LocalDateTime dateTime, ZoneOffset offset)` 从日期时间和偏移量获取 `OffsetDateTime`的实例。
`static OffsetDateTime`	`ofInstant(Instant instant, ZoneId zone)` 从 `Instant`和区域ID获取一个 `OffsetDateTime`的实例。
`static OffsetDateTime`	`parse(CharSequence text)` 从一个文本字符串（如 `2007-12-03T10:15:30+01:00`获取一个 `OffsetDateTime`的实例。
`static OffsetDateTime`	`parse(CharSequence text, DateTimeFormatter formatter)` 使用特定的格式化 `OffsetDateTime`从文本字符串获取一个 `OffsetDateTime`的实例。
`OffsetDateTime`	`plus(long amountToAdd, TemporalUnit unit)` 返回此日期时间的副本，并添加指定的金额。
`OffsetDateTime`	`plus(TemporalAmount amountToAdd)` 返回此日期时间的副本，并添加指定的金额。
`OffsetDateTime`	`plusDays(long days)` 返回此OffsetDateTime的一个副本，并以指定的时间段添加日期。
`OffsetDateTime`	`plusHours(long hours)` 以指定的时间段返回此 `OffsetDateTime`的副本，小时数。
`OffsetDateTime`	`plusMinutes(long minutes)` 以指定的时间（以分钟为单位）返回此 `OffsetDateTime`的副本。
`OffsetDateTime`	`plusMonths(long months)` 返回这个 `OffsetDateTime`的副本，指定的时间段以月为单位。
`OffsetDateTime`	`plusNanos(long nanos)` 返回这个 `OffsetDateTime`的副本，指定的时间段以纳秒为单位。
`OffsetDateTime`	`plusSeconds(long seconds)` 以指定的时间段返回此 `OffsetDateTime`的副本，以秒为单位。
`OffsetDateTime`	`plusWeeks(long weeks)` 以指定的周期返回此OffsetDateTime的副本，以周为单位。
`OffsetDateTime`	`plusYears(long years)` 返回这个 `OffsetDateTime`的副本，其中指定的时间段以添加的年数表示。
`<R> R`	`query(TemporalQuery<R> query)` 使用指定的查询查询此日期时间。
`ValueRange`	`range(TemporalField field)` 获取指定字段的有效值的范围。
`static Comparator<OffsetDateTime>`	`timeLineOrder()` 获取一个比较器，只比较两个 `OffsetDateTime`实例。
`long`	`toEpochSecond()` 将此日期时间转换为从1970-01-01T00：00：00Z的时期开始的秒数。
`Instant`	`toInstant()` 将此日期时间转换为 `Instant` 。
`LocalDate`	`toLocalDate()` 获得这个日期时间的 `LocalDate`部分。
`LocalDateTime`	`toLocalDateTime()` 获得这个偏移日期时间的 `LocalDateTime`部分。
`LocalTime`	`toLocalTime()` 获得这个日期时间的 `LocalTime`部分。
`OffsetTime`	`toOffsetTime()` 将此日期时间转换为 `OffsetTime` 。
`String`	`toString()` 将此日期时间输出为 `String` ，例如 `2007-12-03T10:15:30+01:00` 。
`ZonedDateTime`	`toZonedDateTime()` 使用偏移量作为区域ID将此日期时间转换为 `ZonedDateTime` 。
`OffsetDateTime`	`truncatedTo(TemporalUnit unit)` 返回此副本 `OffsetDateTime`以截断的时间。
`long`	`until(Temporal endExclusive, TemporalUnit unit)` 根据指定的单位计算到另一个日期时间的时间量。
`OffsetDateTime`	`with(TemporalAdjuster adjuster)` 返回此日期时间的调整副本。
`OffsetDateTime`	`with(TemporalField field, long newValue)` 返回此日期时间的副本，并将指定的字段设置为新值。
`OffsetDateTime`	`withDayOfMonth(int dayOfMonth)` 返回此 `OffsetDateTime`的副本。
`OffsetDateTime`	`withDayOfYear(int dayOfYear)` 返回这个 `OffsetDateTime`的副本，并更改日期。
`OffsetDateTime`	`withHour(int hour)` 返回此 `OffsetDateTime`的副本，并更改日期值。
`OffsetDateTime`	`withMinute(int minute)` 返回这个 `OffsetDateTime`的副本，小时值更改。
`OffsetDateTime`	`withMonth(int month)` 返回此年份更改的 `OffsetDateTime`的副本。
`OffsetDateTime`	`withNano(int nanoOfSecond)` 返回这个 `OffsetDateTime`的副本，纳秒变化值。
`OffsetDateTime`	`withOffsetSameInstant(ZoneOffset offset)` 返回此副本 `OffsetDateTime`具有指定偏移确保结果是在同一瞬间。
`OffsetDateTime`	`withOffsetSameLocal(ZoneOffset offset)` 返回此副本 `OffsetDateTime`具有指定偏移确保结果具有相同的本地日期时间。
`OffsetDateTime`	`withSecond(int second)` 返回这个 `OffsetDateTime`的副本，其中二分之一值更改。
`OffsetDateTime`	`withYear(int year)` 返回此年份变更的 `OffsetDateTime`的副本。

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

- 字段详细信息
  - MIN
```
public static final OffsetDateTime MIN
```
    最低支持OffsetDateTime 999999999-01-01T00：00：00 + 18：00'。这是在最大偏移量的最小日期开始的午夜的当地日期时间（更大的偏移在时间线上较早）。这结合了LocalDateTime.MIN和ZoneOffset.MAX 。这可以被应用程序用作“过去”的日期。
  - MAX
```
public static final OffsetDateTime MAX
```
    最大支持OffsetDateTime ，'+ 999999999-12-31T23：59：59.999999999-18：00'。这是在最小偏移量的最大日期结束之前的午夜之前的当地日期时间（较大的负偏移量稍后在时间线上）。这结合了LocalDateTime.MAX和ZoneOffset.MIN 。这个应用程序可以作为“远未来”的日期时间使用。
- 方法详细信息
  - timeLineOrder
```
public static Comparator<OffsetDateTime> timeLineOrder()
```
    获取一个比较器，只比较两个OffsetDateTime实例。
    此方法不同于在比较compareTo(java.time.OffsetDateTime)在于其只比较底层瞬间。
    
    结果
    
    一个比较器可以按时间顺序进行比较
    
    另请参见：
    
    isAfter(java.time.OffsetDateTime) ， isBefore(java.time.OffsetDateTime) ， isEqual(java.time.OffsetDateTime)
  - now
```
public static OffsetDateTime now()
```
    从默认时区的系统时钟获取当前的日期时间。
    这将查询默认时区中的system clock以获取当前的日期时间。偏移量将从时钟的时区计算。
    
    使用此方法将阻止使用备用时钟进行测试，因为时钟是硬编码的。
    
    结果
    
    当前日期时间使用系统时钟，不为空
  - now
```
public static OffsetDateTime now(ZoneId zone)
```
    从指定时区的系统时钟获取当前的日期时间。
    这将查询system clock以获取当前日期。指定时区可以避免对默认时区的依赖。偏移量将从指定的时区计算。
    
    使用此方法将阻止使用备用时钟进行测试，因为时钟是硬编码的。
    
    参数
    
    zone - 要使用的区域ID，不为空
    
    结果
    
    当前日期时间使用系统时钟，不为空
  - now
```
public static OffsetDateTime now(Clock clock)
```
    从指定的时钟获取当前的日期时间。
    这将查询指定的时钟以获取当前的日期时间。偏移量将从时钟的时区计算。
    
    使用此方法可以使用备用时钟进行测试。替代时钟可以使用dependency injection引入。
    
    参数
    
    clock - 要使用的时钟，不为空
    
    结果
    
    当前日期时间，不为null
  - of
```
public static OffsetDateTime of(LocalDate date,
                                LocalTime time,
                                ZoneOffset offset)
```
    从日期，时间和偏移量获取OffsetDateTime的实例。
    这将创建具有指定的本地日期，时间和偏移量的偏移日期时间。
    
    参数
    
    date - 本地日期，不为null
    
    time - 当地时间，不为空
    
    offset - 区域偏移，不为空
    
    结果
    
    偏移日期时间，不为null
  - of
```
public static OffsetDateTime of(LocalDateTime dateTime,
                                ZoneOffset offset)
```
    从日期时间和偏移量获取OffsetDateTime的实例。
    这将创建具有指定的本地日期时间和偏移量的偏移日期时间。
    
    参数
    
    dateTime - 本地日期时间，不为空
    
    offset - 区域偏移，不为空
    
    结果
    
    偏移日期时间，不为null
  - of
```
public static OffsetDateTime of(int year,
                                int month,
                                int dayOfMonth,
                                int hour,
                                int minute,
                                int second,
                                int nanoOfSecond,
                                ZoneOffset offset)
```
    从一年，一个月，一天，一小时，分钟，秒，纳秒和偏移中获取一个OffsetDateTime的实例。
    这将创建与七个指定字段的偏移日期时间。
    
    该方法主要用于编写测试用例。非测试代码通常会使用其他方法来创建一个偏移时间。 LocalDateTime有相当于工厂方法的五个附加便利变体，参数较少。在这里不提供它们来减少API的占用空间。
    
    参数
    
    year - 从MIN_YEAR到MAX_YEAR的年份
    
    month - 从1月1日至12日（12月）的月份，
    
    dayOfMonth - 代表从1到31的月份
    
    hour - 代表从0到23的小时
    
    minute - 从0到59表示的小时
    
    second - 从0到59的秒表示
    
    nanoOfSecond - 表示从0到999,999,999的纳秒
    
    offset - 区域偏移，不为空
    
    结果
    
    偏移日期时间，不为null
    
    异常
    
    DateTimeException - 如果任何字段的值超出范围，或者月的日期对于月份无效
  - ofInstant
```
public static OffsetDateTime ofInstant(Instant instant,
                                       ZoneId zone)
```
    从Instant和区域ID获取一个OffsetDateTime的实例。
    这将创建与指定的相同时间的偏移日期时间。找到UTC /格林威治的偏移量很简单，因为每个瞬间只有一个有效的偏移量。
    
    参数
    
    instant - 即时创建日期时间，不为null
    
    zone - 可能是偏移的时区，不为空
    
    结果
    
    偏移日期时间，不为null
    
    异常
    
    DateTimeException - 如果结果超出了支持的范围
  - from
```
public static OffsetDateTime from(TemporalAccessor temporal)
```
    从时间对象获取一个OffsetDateTime的实例。
    这将基于指定的时间获得偏移日期时间。 A TemporalAccessor表示一个任意的日期和时间信息集，该工厂转换为OffsetDateTime一个实例。
    
    转换将首先从时间对象获取一个ZoneOffset 。然后，它会尝试获取LocalDateTime ，回落至Instant ，如果必要的。其结果将是组合ZoneOffset用或者与LocalDateTime或Instant 。允许实现执行优化，例如访问与相关对象相当的那些字段。
    
    该方法中，功能接口的签名相匹配TemporalQuery允许它在通过方法参考，查询中使用OffsetDateTime::from 。
    
    参数
    
    temporal - 要转换的时间对象，不为null
    
    结果
    
    偏移日期时间，不为null
    
    异常
    
    DateTimeException - 如果无法转换为 OffsetDateTime
  - parse
```
public static OffsetDateTime parse(CharSequence text)
```
    从一个文本字符串（如2007-12-03T10:15:30+01:00获取一个OffsetDateTime的实例。
    字符串必须表示有效的日期时间，并使用DateTimeFormatter.ISO_OFFSET_DATE_TIME进行解析。
    
    参数
    
    text - 要解析的文本，如“2007-12-03T10：15：30 + 01：00”，不为空
    
    结果
    
    解析的偏移日期时间，不为null
    
    异常
    
    DateTimeParseException - 如果文本无法解析
  - parse
```
public static OffsetDateTime parse(CharSequence text,
                                   DateTimeFormatter formatter)
```
    使用特定格式化OffsetDateTime从文本字符串获取OffsetDateTime的实例。
    使用格式化程序解析文本，返回日期时间。
    
    参数
    
    text - 要解析的文本，不为空
    
    formatter - 要使用的格式化程序，不为null
    
    结果
    
    解析的偏移日期时间，不为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在界面 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作为参数。设备是否受支持由本机决定。
    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在接口 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作为参数的this获得的。该值是否可以获得，该值代表什么值由该字段决定。
    
    Specified by:
    
    get在界面 TemporalAccessor
    
    参数
    
    field - 要获取的字段，不为null
    
    结果
    
    该字段的值
    
    异常
    
    DateTimeException - 如果无法获取该字段的值，或者该值超出该字段有效值的范围
    
    UnsupportedTemporalTypeException - 如果该字段不受支持或值的范围超过 int
    
    ArithmeticException - 如果发生数字溢出
  - getLong
```
public long getLong(TemporalField field)
```
    从此日期时间获取指定字段的值为long 。
    这将查询指定字段的值的日期时间。如果不可能返回值，因为该字段不受支持或出于某种其他原因，则抛出异常。
    
    如果字段是ChronoField，那么查询是在这里实现的。 supported fields将根据此日期时间返回有效值。所有其他ChronoField实例将抛出一个UnsupportedTemporalTypeException 。
    
    如果该字段是不是一个ChronoField ，则此方法的结果是通过调用获得TemporalField.getFrom(TemporalAccessor)传递this作为参数。该值是否可以获得，该值代表什么值由该字段决定。
    
    Specified by:
    
    getLong在界面 TemporalAccessor
    
    参数
    
    field - 要获取的字段，不为null
    
    结果
    
    该字段的值
    
    异常
    
    DateTimeException - 如果无法获得该字段的值
    
    UnsupportedTemporalTypeException - 如果该字段不被支持
    
    ArithmeticException - 如果发生数字溢出
  - getOffset
```
public ZoneOffset getOffset()
```
    获取区域偏移量，例如“+01：00”。
    这是当地时间与UTC /格林威治的抵消。
    
    结果
    
    区域偏移，不为空
  - withOffsetSameLocal
```
public OffsetDateTime withOffsetSameLocal(ZoneOffset offset)
```
    以指定的偏移量返回此OffsetDateTime的副本，确保结果具有相同的本地日期时间。
    此方法返回具有相同的对象LocalDateTime和指定的ZoneOffset 。不需要或执行计算。例如，如果此时间表示2007-12-03T10:30+02:00 ，并且指定的偏移量为+03:00 ，则此方法将返回2007-12-03T10:30+03:00 。
    
    要考虑到偏移量之间的差异，并调整时间段，请使用withOffsetSameInstant(java.time.ZoneOffset) 。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    offset - 要更改的区域偏移量，不为空
    
    结果
    
    一个 OffsetDateTime基于此日期时间与请求的偏移量，不为null
  - withOffsetSameInstant
```
public OffsetDateTime withOffsetSameInstant(ZoneOffset offset)
```
    返回此副本OffsetDateTime具有指定偏移确保结果是在同一瞬间。
    此方法返回一个具有指定的对象ZoneOffset和LocalDateTime由两个偏移之间的LocalDateTime进行调整。这将导致旧的和新的对象代表相同的时刻。这对于在不同的偏移量中找到本地时间是有用的。例如，如果此时间表示2007-12-03T10:30+02:00 ，并且指定的偏移量为+03:00 ，则此方法将返回2007-12-03T11:30+03:00 。
    
    要更改偏移量而不调整本地时间使用withOffsetSameLocal(java.time.ZoneOffset) 。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    offset - 要更改的区域偏移量，不为空
    
    结果
    
    一个 OffsetDateTime基于这个日期时间与请求的偏移量，不为null
    
    异常
    
    DateTimeException - 如果结果超出支持的日期范围
  - toLocalDateTime
```
public LocalDateTime toLocalDateTime()
```
    获得这个偏移日期时间的LocalDateTime部分。
    这将返回一个LocalDateTime与这个日期时间相同的年，月，日和时间。
    
    结果
    
    这个日期时间的本地日期时间部分，不为空
  - toLocalDate
```
public LocalDate toLocalDate()
```
    获得这个日期时间的LocalDate部分。
    这将返回一个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。
    该方法将一个月从int个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那么枚举将提供int value 。
    
    附加信息可以从DayOfWeek获得。这包括值的文本名称。
    
    结果
    
    星期几不为零
  - toLocalTime
```
public LocalTime toLocalTime()
```
    获得这个日期时间的LocalTime部分。
    这在这个日期时间内返回一个LocalTime与同样的小时，分，秒和纳秒。
    
    结果
    
    这个日期时间的一部分，不是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 OffsetDateTime with(TemporalAdjuster adjuster)
```
    返回此日期时间的调整副本。
    这返回一个OffsetDateTime ，基于这一个，日期时间调整。调整使用指定的调整器策略对象进行。阅读调整器的文档，了解将进行什么调整。
    
    一个简单的调整器可能只是设置一个字段，如年份字段。更复杂的调整器可能会将日期设置为该月的最后一天。 TemporalAdjuster提供了一些常见的调整。这些包括找到“月的最后一天”和“下周三”。关键的日期课程也实现了TemporalAdjuster界面，如Month和MonthDay 。调整员负责处理特殊情况，如月份和闰年的不同长度。
    
    例如这个代码在7月的最后一天返回一个日期：
```
  import static java.time.Month.*;
  import static java.time.temporal.Adjusters.*;

  result = offsetDateTime.with(JULY).with(lastDayOfMonth()); 
```
    类LocalDate ， LocalTime和ZoneOffset实施TemporalAdjuster ，从而可以用这种方法来改变日期，时间或偏移：
```
  result = offsetDateTime.with(date);
  result = offsetDateTime.with(time);
  result = offsetDateTime.with(offset); 
```
    该方法的结果是通过调用TemporalAdjuster.adjustInto(Temporal)方法获得的指定调整器通过this作为参数。
    
    此实例是不可变的，不受此方法调用的影响。
    Specified by:
    
    with在界面 Temporal
    
    参数
    
    adjuster - 调整器使用，不为空
    
    结果
    
    一个 OffsetDateTime基于 this进行了调整，不为null
    
    异常
    
    DateTimeException - 如果不能进行调整
    
    ArithmeticException - 如果发生数字溢出
  - with
```
public OffsetDateTime with(TemporalField field,
                           long newValue)
```
    返回此日期时间的副本，并将指定的字段设置为新值。
    OffsetDateTime返回一个OffsetDateTime ，基于此一个，指定字段的值更改。这可以用于更改任何支持的字段，例如年，月或月。如果不可能设置该值，因为该字段不受支持或出于某种其他原因，则抛出异常。
    
    在某些情况下，更改指定的字段可能会导致生成的日期时间变得无效，例如将月份从1月31日更改为2月将导致日期无效。在这种情况下，该领域负责解决日期。通常，它将选择先前的有效日期，这将是本例中最后一个有效的二月份。
    
    如果该字段是ChronoField，则在此处执行调整。
    
    INSTANT_SECONDS字段将返回指定时间的日期时间。偏移和纳秒不变。如果新的即时值超出有效范围，那么将抛出一个DateTimeException 。
    
    OFFSET_SECONDS字段将返回指定偏移量的日期时间。当地的日期时间是不变的。如果新的偏移值超出有效范围，那么将抛出一个DateTimeException 。
    
    其他supported fields将按照LocalDateTime的匹配方法进行操作。在这种情况下，偏移不是计算的一部分，将不会改变。
    
    所有其他ChronoField实例将抛出一个UnsupportedTemporalTypeException 。
    
    如果该字段是不是一个ChronoField ，则此方法的结果是通过调用获得TemporalField.adjustInto(Temporal, long)传递this作为参数。在这种情况下，该字段决定是否以及如何调整即时。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    with在接口 Temporal
    
    参数
    
    field - 要在结果中设置的字段，不为空
    
    newValue - 结果中字段的新值
    
    结果
    
    一个 OffsetDateTime基于 this与指定的字段集，不为null
    
    异常
    
    DateTimeException - 如果该字段无法设置
    
    UnsupportedTemporalTypeException - 如果该字段不被支持
    
    ArithmeticException - 如果发生数字溢出
  - withYear
```
public OffsetDateTime withYear(int year)
```
    返回此年份变更的OffsetDateTime的副本。偏移量不影响计算，结果将相同。如果一年中的日期无效，它将被更改为该月的最后一个有效日期。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    year - 从MIN_YEAR到MAX_YEAR的结果年份
    
    结果
    
    一个 OffsetDateTime基于这个日期时间与请求的一年，不为null
    
    异常
    
    DateTimeException - 如果年值无效
  - withMonth
```
public OffsetDateTime withMonth(int month)
```
    返回此年份更改的OffsetDateTime的副本。偏移量不影响计算，结果将相同。如果一年中的日期无效，它将被更改为该月的最后一个有效日期。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    month - 从1月1日至12日（12月），确定结果的月份
    
    结果
    
    一个 OffsetDateTime基于这个日期时间与请求的月份，不为null
    
    异常
    
    DateTimeException - 如果月份值无效
  - withDayOfMonth
```
public OffsetDateTime withDayOfMonth(int dayOfMonth)
```
    返回这个OffsetDateTime的副本，并更改日期。如果生成的OffsetDateTime无效，则会抛出异常。偏移量不影响计算，结果将相同。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    dayOfMonth - 在1月28日至31日之间确定结果的月份
    
    结果
    
    一个 OffsetDateTime基于这个日期时间与请求的一天，不为null
    
    异常
    
    DateTimeException - 如果月日的价值无效，或者月的月日无效的月份
  - withDayOfYear
```
public OffsetDateTime withDayOfYear(int dayOfYear)
```
    返回这个OffsetDateTime的副本，并更改日期。如果得到OffsetDateTime是无效的，则抛出异常。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    dayOfYear - 设定结果的日期，从1到365-366
    
    结果
    
    一个 OffsetDateTime基于这个日期与请求的一天，不为null
    
    异常
    
    DateTimeException - 如果日期年值无效，或者如果当年的日期无效
  - withHour
```
public OffsetDateTime withHour(int hour)
```
    返回这个OffsetDateTime的副本，日期值更改。
    偏移量不影响计算，结果将相同。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    hour - 设置结果的时间从0到23
    
    结果
    
    一个 OffsetDateTime基于这个日期时间与请求的小时，不为null
    
    异常
    
    DateTimeException - 如果小时值无效
  - withMinute
```
public OffsetDateTime withMinute(int minute)
```
    返回这个OffsetDateTime的副本，小时值更改。
    偏移量不影响计算，结果将相同。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    minute - 在0到59之间设置结果的小时
    
    结果
    
    一个 OffsetDateTime基于这个日期时间与请求的分钟，不为null
    
    异常
    
    DateTimeException - 如果分钟值无效
  - withSecond
```
public OffsetDateTime withSecond(int second)
```
    返回这个OffsetDateTime的副本，其中OffsetDateTime了第二分钟的值。
    偏移量不影响计算，结果将相同。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    second - 在0到59之间设置结果的 second
    
    结果
    
    一个 OffsetDateTime基于这个日期时间与请求的第二个，不为null
    
    异常
    
    DateTimeException - 如果第二个值无效
  - withNano
```
public OffsetDateTime withNano(int nanoOfSecond)
```
    返回这个OffsetDateTime的副本，纳秒变化值。
    偏移量不影响计算，结果将相同。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    nanoOfSecond - 纳秒秒在结果中设置，从0到999,999,999
    
    结果
    
    一个 OffsetDateTime基于这个日期时间与请求的纳秒，不为null
    
    异常
    
    DateTimeException - 如果 DateTimeException值无效
  - truncatedTo
```
public OffsetDateTime truncatedTo(TemporalUnit unit)
```
    返回此副本OffsetDateTime以截断的时间。
    截断返回原始日期时间的副本，其中小于指定单位的字段设置为零。例如，使用minutes单位进行截断将将第二分钟和第二纳秒字段设置为零。
    
    该单位必须有一个duration ，划分为标准日期的长度，无余数。这包括所有提供的时间单位在ChronoUnit和DAYS 。其他单位抛出异常。
    
    偏移量不影响计算，结果将相同。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    unit - 截断到的单位，不为空
    
    结果
    
    一个 OffsetDateTime基于此日期时间截断，不为null
    
    异常
    
    DateTimeException - 如果无法截断
    
    UnsupportedTemporalTypeException - 如果不支持本机
  - plus
```
public OffsetDateTime plus(TemporalAmount amountToAdd)
```
    返回此日期时间的副本，并添加指定的金额。
    这将返回一个OffsetDateTime ，基于这一个，添加了指定的数量。量通常是Period或Duration ，而可以是任何其他类型的实现TemporalAmount接口。
    
    通过调用TemporalAmount.addTo(Temporal)将计算委托给金额对象。数量执行可以以任何方式实现添加，但是它通常会回调到plus(long, TemporalUnit) 。请参阅金额执行的文档，以确定是否可以成功添加。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    plus在界面 Temporal
    
    参数
    
    amountToAdd - 要添加的金额，不为null
    
    结果
    
    一个 OffsetDateTime基于这个日期时间与添加，而不是null
    
    异常
    
    DateTimeException - 如果不能添加
    
    ArithmeticException - 如果发生数字溢出
  - plus
```
public OffsetDateTime plus(long amountToAdd,
                           TemporalUnit unit)
```
    返回此日期时间的副本，并添加指定的金额。
    这返回一个OffsetDateTime ，基于这一个，以添加的单位的数量。如果不可能添加金额，因为单位不受支持或出于某种其他原因，则抛出异常。
    
    如果该字段是一个ChronoUnit，那么这个添加是由LocalDateTime.plus(long, TemporalUnit)实现的。偏移量不是计算的一部分，结果将不变。
    
    如果该字段是不是一个ChronoUnit ，则此方法的结果是通过调用获得TemporalUnit.addTo(Temporal, long)传递this作为参数。在这种情况下，单元确定是否以及如何执行添加。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    plus在界面 Temporal
    
    参数
    
    amountToAdd - 添加到结果中的单位数量可能为负数
    
    unit - 要添加的单位，不为空
    
    结果
    
    一个 OffsetDateTime基于此日期时间与指定的数量添加，不为null
    
    异常
    
    DateTimeException - 如果不能添加
    
    UnsupportedTemporalTypeException - 如果不支持本机
    
    ArithmeticException - 如果发生数字溢出
  - plusYears
```
public OffsetDateTime plusYears(long years)
```
    返回这个OffsetDateTime的副本，其中指定的时间段以年增加。
    该方法通过三个步骤将指定的数量添加到年份字段：
    1. 将输入年份添加到年份字段
    2. 检查结果日期是否无效
    3. 如果有必要，将月份调整到最后一个有效日期
    例如，2008-02-29（闰年）加上一年将导致无效日期2009-02-29（标准年）。而不是返回无效结果，而是选择2009-02-28的最后一个有效日期。
    
    此实例是不可变的，不受此方法调用的影响。
    参数
    
    years - 多年来补充，可能是负数
    
    结果
    
    一个 OffsetDateTime基于这个日期时间与添加的年份，不为null
    
    异常
    
    DateTimeException - 如果结果超出支持的日期范围
  - plusMonths
```
public OffsetDateTime plusMonths(long months)
```
    返回这个OffsetDateTime的副本，其中指定的时间段以月为单位。
    此方法通过三个步骤将指定的数量添加到月份字段：
    1. 将输入的月份添加到月份字段
    2. 检查结果日期是否无效
    3. 如果有必要，将月份调整到最后一个有效日期
    例如，2007-03-31加上一个月将导致无效日期2007-04-31。而不是返回无效结果，而是选择2007-04-30的最后一个有效日期。
    
    此实例是不可变的，不受此方法调用的影响。
    参数
    
    months - 要添加的月份，可能为负数
    
    结果
    
    一个 OffsetDateTime基于这个日期时间与添加的月份，不为null
    
    异常
    
    DateTimeException - 如果结果超出支持的日期范围
  - plusWeeks
```
public OffsetDateTime plusWeeks(long weeks)
```
    以指定的周期返回此OffsetDateTime的副本，以周为单位。
    该方法将指定的数量以周为单位，根据需要增加月份和年份字段的日期字段，以确保结果保持有效。如果超过最大/最小年份，结果将无效。
    
    例如，2008-12-31加上一周将导致2009-01-07。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    weeks - 添加的星期可能为负数
    
    结果
    
    一个 OffsetDateTime基于这个日期时间与添加的星期，不为null
    
    异常
    
    DateTimeException - 如果结果超出支持的日期范围
  - plusDays
```
public OffsetDateTime plusDays(long days)
```
    返回此OffsetDateTime的一个副本，并以指定的时间段添加日期。
    此方法将指定的金额添加到天数字段中，根据需要增加月份和年份字段，以确保结果保持有效。如果超过最大/最小年份，结果将无效。
    
    例如，2008-12-31加上一天会导致2009-01-01。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    days - 添加的日子可能为负数
    
    结果
    
    一个 OffsetDateTime基于这个日期时间与添加的天数，不为null
    
    异常
    
    DateTimeException - 如果结果超出支持的日期范围
  - plusHours
```
public OffsetDateTime plusHours(long hours)
```
    以指定的时间（以小时为单位）返回此OffsetDateTime的副本。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    hours - 要添加的时间可能为负数
    
    结果
    
    一个 OffsetDateTime基于这个日期时间添加的时间，不为null
    
    异常
    
    DateTimeException - 如果结果超出支持的日期范围
  - plusMinutes
```
public OffsetDateTime plusMinutes(long minutes)
```
    以指定的时间（以分钟为单位）返回此OffsetDateTime的副本。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    minutes - 要添加的分钟，可能为负数
    
    结果
    
    一个 OffsetDateTime基于此日期时间添加分钟，不为null
    
    异常
    
    DateTimeException - 如果结果超出支持的日期范围
  - plusSeconds
```
public OffsetDateTime plusSeconds(long seconds)
```
    以指定的时间段返回此OffsetDateTime的副本，以秒为单位。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    seconds - 添加的秒数可能为负数
    
    结果
    
    一个 OffsetDateTime基于这个日期时间添加秒，不为null
    
    异常
    
    DateTimeException - 如果结果超出支持的日期范围
  - plusNanos
```
public OffsetDateTime plusNanos(long nanos)
```
    返回这个OffsetDateTime的副本，指定的时间段以纳秒为单位。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    nanos - nanos添加，可能是负的
    
    结果
    
    一个 OffsetDateTime基于这个日期时间加上纳秒，不为null
    
    异常
    
    DateTimeException - 如果单位无法添加到此类型
  - minus
```
public OffsetDateTime minus(TemporalAmount amountToSubtract)
```
    返回此日期时间的副本，并减去指定的金额。
    这将返回一个OffsetDateTime ，基于此，减去指定的数量。量通常是Period或Duration ，而可以是任何其他类型的实现TemporalAmount接口。
    
    通过调用TemporalAmount.subtractFrom(Temporal)将计算委托给金额对象。数量执行可以以任何方式实现减法，但是它通常会回调到minus(long, TemporalUnit) 。请参阅数量实施的文档，以确定是否可以成功减去它们。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    minus在界面 Temporal
    
    参数
    
    amountToSubtract - 减去量，不为空
    
    结果
    
    一个 OffsetDateTime基于这个日期时间与减法而不是null
    
    异常
    
    DateTimeException - 如果不能进行减法
    
    ArithmeticException - 如果发生数字溢出
  - minus
```
public OffsetDateTime minus(long amountToSubtract,
                            TemporalUnit unit)
```
    返回此日期时间的副本，并减去指定的金额。
    这将返回一个OffsetDateTime ，基于这一个，减去单位的数额。如果不可能减去金额，因为该单位不受支持或出于某种其他原因，则会抛出异常。
    
    这种方法相当于plus(long, TemporalUnit) ，数量被否定。请参阅该方法，以了解如何添加，从而减去运算。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    minus在界面 Temporal
    
    参数
    
    amountToSubtract - 从结果中减去单位的数量可能为负数
    
    unit - 减去量的单位，不为空
    
    结果
    
    一个 OffsetDateTime基于此日期时间减去指定的数量，不为null
    
    异常
    
    DateTimeException - 如果不能进行减法
    
    UnsupportedTemporalTypeException - 如果不支持本机
    
    ArithmeticException - 如果发生数字溢出
  - minusYears
```
public OffsetDateTime minusYears(long years)
```
    返回此OffsetDateTime的副本，以减去的年份为单位。
    该方法从三个步骤中减去指定的数量：
    1. 减去输入年份到年份字段
    2. 检查结果日期是否无效
    3. 如果有必要，将月份调整到最后一个有效日期
    例如，2008-02-29（闰年）减去一年将导致无效日期2009-02-29（标准年）。而不是返回无效结果，而是选择2009-02-28的最后一个有效日期。
    
    此实例是不可变的，不受此方法调用的影响。
    参数
    
    years - 减去年份，可能为负数
    
    结果
    
    一个 OffsetDateTime基于这个日期时间与减去的年份，不为null
    
    异常
    
    DateTimeException - 如果结果超出支持的日期范围
  - minusMonths
```
public OffsetDateTime minusMonths(long months)
```
    返回此OffsetDateTime的副本，指定的时间以月为单位减去。
    该方法从以下三个步骤中减去月份字段中指定的数量：
    1. 将输入月份减去月份字段
    2. 检查结果日期是否无效
    3. 如果有必要，将月份调整到最后一个有效日期
    例如，2007-03-31减去一个月将导致无效日期2007-04-31。而不是返回无效结果，而是选择2007-04-30的最后一个有效日期。
    
    此实例是不可变的，不受此方法调用的影响。
    参数
    
    months - 减去的月份，可能是负数
    
    结果
    
    一个 OffsetDateTime基于这个日期时间与减去的月份，不为null
    
    异常
    
    DateTimeException - 如果结果超出支持的日期范围
  - minusWeeks
```
public OffsetDateTime minusWeeks(long weeks)
```
    返回此OffsetDateTime的副本，其中指定的周期以周为单位减去。
    该方法从必要的日期字段减去月和年字段中减去指定的数量，以确保结果保持有效。如果超过最大/最小年份，结果将无效。
    
    例如，2008-12-31减去一周将导致2009-01-07。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    weeks - 减去的星期可能是负数
    
    结果
    
    一个 OffsetDateTime基于这个日期时间与减去的星期，不为null
    
    异常
    
    DateTimeException - 如果结果超出支持的日期范围
  - minusDays
```
public OffsetDateTime minusDays(long days)
```
    以指定的时间段返回此OffsetDateTime的副本，减去日期。
    该方法从天数字段减去指定数量，根据需要增加月份和年份字段，以确保结果保持有效。如果超过最大/最小年份，结果将无效。
    
    例如，2008-12-31减去一天会导致2009-01-01。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    days - 减去的日子可能是负数
    
    结果
    
    一个 OffsetDateTime基于这个日期时间 OffsetDateTime的日期，不为null
    
    异常
    
    DateTimeException - 如果结果超出了支持的日期范围
  - minusHours
```
public OffsetDateTime minusHours(long hours)
```
    以指定的时间段返回此OffsetDateTime的副本，以减少的小时数。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    hours - 减去的时间可能为负数
    
    结果
    
    一个 OffsetDateTime基于这个日期时间减去的小时，不为null
    
    异常
    
    DateTimeException - 如果结果超出支持的日期范围
  - minusMinutes
```
public OffsetDateTime minusMinutes(long minutes)
```
    返回此OffsetDateTime的副本，其中指定的时间间隔以分钟为单位。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    minutes - 减去的 minutes可能为负数
    
    结果
    
    一个 OffsetDateTime基于此日期时间减去分钟，不为空
    
    异常
    
    DateTimeException - 如果结果超出支持的日期范围
  - minusSeconds
```
public OffsetDateTime minusSeconds(long seconds)
```
    返回此OffsetDateTime的副本，其中指定的时间间隔以秒为单位。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    seconds - 减去的秒数可能为负数
    
    结果
    
    一个 OffsetDateTime基于此日期时间减去秒，而不是null
    
    异常
    
    DateTimeException - 如果结果超出支持的日期范围
  - minusNanos
```
public OffsetDateTime minusNanos(long nanos)
```
    返回这个OffsetDateTime的副本，以指定的时间减去纳秒。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    nanos - nanos减去，可能是负数
    
    结果
    
    一个 OffsetDateTime基于这个日期时间减去纳秒，不为null
    
    异常
    
    DateTimeException - 如果结果超出支持的日期范围
  - query
```
public <R> R query(TemporalQuery<R> query)
```
    使用指定的查询查询此日期时间。
    这将使用指定的查询策略对象查询此日期时间。 TemporalQuery对象定义了用于获取结果的逻辑。阅读查询的文档，以了解该方法的结果。
    
    该方法的结果是通过调用指定的查询this作为参数的TemporalQuery.queryFrom(TemporalAccessor)方法获得的。
    
    Specified by:
    
    query在界面 TemporalAccessor
    
    参数类型
    
    R - 结果的类型
    
    参数
    
    query - 要调用的查询，不为空
    
    结果
    
    查询结果可能返回null（由查询定义）
    
    异常
    
    DateTimeException - 如果无法查询（由查询定义）
    
    ArithmeticException - 如果发生数字溢出（由查询定义）
  - adjustInto
```
public Temporal adjustInto(Temporal temporal)
```
    调整指定的时间对象与此对象具有相同的偏移量，日期和时间。
    这返回与偏移量相同的可观察类型的时间对象，偏移量，日期和时间更改为与此相同。
    
    该调整是相当于使用Temporal.with(TemporalField, long)两三次，传球ChronoField.EPOCH_DAY ， ChronoField.NANO_OF_DAY和ChronoField.OFFSET_SECONDS作为字段。
    
    在大多数情况下，通过使用Temporal.with(TemporalAdjuster)来更正调用模式：
```
  // these two lines are equivalent, but the second approach is recommended
   temporal = thisOffsetDateTime.adjustInto(temporal);
   temporal = temporal.with(thisOffsetDateTime); 
```
    此实例是不可变的，不受此方法调用的影响。
    Specified by:
    
    adjustInto在界面 TemporalAdjuster
    
    参数
    
    temporal - 要调整的目标对象，不为null
    
    结果
    
    调整对象，不为null
    
    异常
    
    DateTimeException - 如果不能进行调整
    
    ArithmeticException - 如果发生数字溢出
  - until
```
public long until(Temporal endExclusive,
                  TemporalUnit unit)
```
    根据指定的单位计算到另一个日期时间的时间量。
    这可以计算两个OffsetDateTime对象之间的时间量，单个TemporalUnit 。起点和终点是this和指定的日期时间。如果结束在开始之前，结果将为负数。例如，可以使用startDateTime.until(endDateTime, DAYS)两个日期时间之间的时间startDateTime.until(endDateTime, DAYS) 。
    
    所述Temporal传递给此方法被转换为OffsetDateTime使用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值将抛出异常。
    
    如果该单元不是ChronoUnit ，则此方法的结果是通过调用获得TemporalUnit.between(Temporal, Temporal)传递this作为第一个参数和转换后的输入时间作为第二个参数。
    
    此实例是不可变的，不受此方法调用的影响。
    Specified by:
    
    until在界面 Temporal
    
    参数
    
    endExclusive - 结束日期，排他，转换为 OffsetDateTime ，不为空
    
    unit - 衡量金额的单位，不为空
    
    结果
    
    在此日期和结束日期时间之间的时间量
    
    异常
    
    DateTimeException - 如果不能计算金额，或者结束时间不能转换为 OffsetDateTime
    
    UnsupportedTemporalTypeException - 如果不支持本机
    
    ArithmeticException - 如果发生数字溢出
  - format
```
public String format(DateTimeFormatter formatter)
```
    使用指定的格式化程序格式化此日期时间。
    这个日期时间将传递给格式化程序以生成一个字符串。
    
    参数
    
    formatter - 要使用的格式化程序，不为null
    
    结果
    
    格式化的日期时间字符串，不为空
    
    异常
    
    DateTimeException - 打印时是否发生错误
  - atZoneSameInstant
```
public ZonedDateTime atZoneSameInstant(ZoneId zone)
```
    将此日期时间与时区组合以创建ZonedDateTime确保结果具有相同的时刻。
    这将返回一个ZonedDateTime从这个日期，时间和指定的时区形成。此转换将忽略可见的本地日期时间，并使用底层即时代替。这避免了当地时间线间隙或重叠的任何问题。结果可能会有不同的值，例如小时，分钟甚至偶数天。
    
    要尝试保留字段的值，请使用atZoneSimilarLocal(ZoneId) 。要使用偏移量作为区域ID，请使用toZonedDateTime() 。
    
    参数
    
    zone - 使用的时区，不为空
    
    结果
    
    从这个日期时间形成的划分的日期时间，不为null
  - atZoneSimilarLocal
```
public ZonedDateTime atZoneSimilarLocal(ZoneId zone)
```
    将此日期时间与时区组合，以创建一个ZonedDateTime尝试保持相同的本地日期和时间。
    这将返回一个ZonedDateTime从这个日期，时间和指定的时区形成。在可能的情况下，结果将具有与该对象相同的本地日期时间。
    
    时区规则，如夏令时，意味着不是每次当地时间线都存在。如果本地日期时间根据规则处于间隙或重叠，则使用解析器来确定合成的本地时间和偏移量。如果可能，此方法使用ZonedDateTime.ofLocal(LocalDateTime, ZoneId, ZoneOffset)保留此实例的偏移量。
    
    间隙和重叠的更好的控制有两种方式。如果您只想在重叠时使用较晚的偏移量，则在此方法后立即调用ZonedDateTime.withLaterOffsetAtOverlap() 。
    
    要在同一时刻创建分区的日期时间，无论本地时间线如何，请使用atZoneSameInstant(ZoneId) 。要使用偏移量作为区域ID，请使用toZonedDateTime() 。
    
    参数
    
    zone - 使用的时区，不为空
    
    结果
    
    从该日期形成的划区日期时间和区域的最早有效时间，不为空
  - toOffsetTime
```
public OffsetTime toOffsetTime()
```
    将此日期时间转换为OffsetTime 。
    这将返回具有相同本地时间和偏移量的偏移时间。
    
    结果
    
    表示时间和偏移的OffsetTime，不为null
  - toZonedDateTime
```
public ZonedDateTime toZonedDateTime()
```
    将此日期时间转换为ZonedDateTime使用偏移量作为区域ID。
    这将创建最简单的ZonedDateTime使用偏移作为区域ID。
    
    要控制使用的时区，请参阅atZoneSameInstant(ZoneId)和atZoneSimilarLocal(ZoneId) 。
    
    结果
    
    表示相同本地日期时间和偏移量的分区日期时间，不为空
  - toInstant
```
public Instant toInstant()
```
    将此日期时间转换为Instant 。
    这将返回一个Instant ，表示与此日期时间相同的时间点。
    
    结果
    
    一个 Instant表示相同的时刻，不为空
  - toEpochSecond
```
public long toEpochSecond()
```
    将此日期时间转换为从1970-01-01T00：00：00Z的时期开始的秒数。
    这样可以将此日期时间转换为epoch-seconds字段的值。这主要用于低级转换，而不是一般的应用程序使用。
    
    结果
    
    从1970-01-01T00：00：00Z的时代开始的秒数
  - compareTo
```
public int compareTo(OffsetDateTime other)
```
    将此OffsetDateTime与其他日期时间进行比较。
    比较是基于当时的当地日期时间。它与“等于”一致，如Comparable所定义。
    
    例如，以下是比较器顺序：
    1. 2008-12-03T10:30+01:00
    2. 2008-12-03T11:00+01:00
    3. 2008-12-03T12:00+02:00
    4. 2008-12-03T11:30+01:00
    5. 2008-12-03T12:00+01:00
    6. 2008-12-03T12:30+01:00
    值2和＃3表示时间线上相同的时刻。当两个值表示相同的时刻时，将本地日期时间进行比较以区分它们。需要这一步才能使订购与equals() 。
    Specified by:
    
    compareTo在界面 Comparable<OffsetDateTime>
    
    参数
    
    other - 其他日期时间来比较，不为null
    
    结果
    
    比较器值为负，如果较小，则如果较大则为正
  - isAfter
```
public boolean isAfter(OffsetDateTime other)
```
    检查此日期时间是否在指定的日期时间之后。
    该方法与compareTo(java.time.OffsetDateTime)和equals(java.lang.Object)中的比较不同之处在于它仅比较日期时间的时间。这相当于使用dateTime1.toInstant().isAfter(dateTime2.toInstant()); 。
    
    参数
    
    other - 其他日期时间来比较，不为null
    
    结果
    
    如果这是在指定的日期时间之后，则为真
  - isBefore
```
public boolean isBefore(OffsetDateTime other)
```
    检查此日期时间是否在指定的日期时间之前。
    此方法不同于在比较compareTo(java.time.OffsetDateTime)在于其只比较的日期时间的时刻。这相当于使用dateTime1.toInstant().isBefore(dateTime2.toInstant()); 。
    
    参数
    
    other - 其他日期时间来比较，不为null
    
    结果
    
    如果这是在指定的日期时间之前，则为true
  - isEqual
```
public boolean isEqual(OffsetDateTime other)
```
    检查此日期时间的时间是否等于指定的日期时间。
    该方法与compareTo(java.time.OffsetDateTime)和equals(java.lang.Object)中的比较不同，它只比较日期时间的时间。这相当于使用dateTime1.toInstant().equals(dateTime2.toInstant()); 。
    
    参数
    
    other - 其他日期时间来比较，不为空
    
    结果
    
    如果瞬间等于指定日期时间的时间，则为true
  - equals
```
public boolean equals(Object obj)
```
    检查这个日期时间是否等于另一个日期时间。
    比较是基于本地日期时间和偏移量。要在时间线上比较同一时刻，请使用isEqual(java.time.OffsetDateTime) 。只比较类型为OffsetDateTime对象，其他类型返回false。
    
    重写：
    
    equals在 Object
    
    参数
    
    obj - 要检查的对象，null返回false
    
    结果
    
    如果这等于其他日期时间，则为true
    
    另请参见：
    
    Object.hashCode() ， HashMap
  - hashCode
```
public int hashCode()
```
    这个日期时间的哈希码。
    
    重写：
    
    hashCode在 Object
    
    结果
    
    一个合适的哈希码
    
    另请参见：
    
    Object.equals(java.lang.Object) ， System.identityHashCode(java.lang.Object)
  - toString
```
public String toString()
```
    将此日期时间输出为String ，例如2007-12-03T10:15:30+01:00 。
    输出将是以下ISO-8601格式之一：
    - uuuu-MM-dd'T'HH:mmXXXXX
    - uuuu-MM-dd'T'HH:mm:ssXXXXX
    - uuuu-MM-dd'T'HH:mm:ss.SSSXXXXX
    - uuuu-MM-dd'T'HH:mm:ss.SSSSSSXXXXX
    - uuuu-MM-dd'T'HH:mm:ss.SSSSSSSSSXXXXX
    所使用的格式将是将省略部分隐含为零的时间的全部值输出的最短。
    重写：
    
    toString在 Object
    
    结果
    
    此日期时间的字符串表示形式，不为null

Class OffsetDateTime

Field Summary

方法摘要

Methods inherited from class java.lang.Object

字段详细信息

MIN

MAX

方法详细信息

timeLineOrder

now

now

now

of

of

of

ofInstant

from

parse

parse

isSupported

isSupported

range

get

getLong

getOffset

withOffsetSameLocal

withOffsetSameInstant

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

adjustInto

until

format

atZoneSameInstant

atZoneSimilarLocal

toOffsetTime

toZonedDateTime

toInstant