LocalDateTime (Java Platform SE 8 )

java.lang.Object
- java.time.LocalDateTime

All Implemented Interfaces:

Serializable， Comparable < ChronoLocalDateTime <？> >，<< ChronoLocalDateTime LocalDate >， Temporal， TemporalAccessor， TemporalAdjuster
```
public final class LocalDateTime
extends Object
implements Temporal, TemporalAdjuster, ChronoLocalDateTime<LocalDate>, Serializable
```
一个没有在ISO-8601日历系统时区的日期时间，如 2007-12-03T10:15:30。
LocalDateTime是不变的日期时间对象代表一个日期时间，往往被视为年、月、日、时、分、秒。其他日期和时间字段，如一年中的一天，一周和一周的一天，也可以访问。时间为代表的纳秒级精度。例如，值“2007年10月2日在13:45.30.123456789”可以存储在一个LocalDateTime。

这个类不存储或表示一个时区。相反，它是一个描述的日期，如用于生日，结合当地时间在墙上的时钟。它不能代表时间线上的即时，而不需要额外的信息，如偏移或时区。

该系统是现代民法ISO-8601日历日历系统中使用的大多数今天的世界。它相当于proleptic公历闰年的系统，在今天的规则适用于所有的时间。今天的大多数应用程序编写的，完全适合的ISO-8601规则。然而，任何应用程序，利用历史数据，并要求他们要准确找到ISO-8601方法不当。

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

实现要求：

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

从以下版本开始：

一点八

另请参见：

Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`static LocalDateTime`	`MAX` 所支持的最大 `LocalDateTime`，' + 999999999 -12-31t23:59:59. 999999999。
`static LocalDateTime`	`MIN` 最小支持 `LocalDateTime`，”999999999 -01-01t00:00:00”。

方法摘要

所有方法静态方法接口方法具体的方法
Modifier and Type	Method and Description
`Temporal`	`adjustInto(Temporal temporal)` 调整指定的时间对象，以具有相同的日期和时间为对象。
`OffsetDateTime`	`atOffset(ZoneOffset offset)` 结合这个日期时间偏移来创建一个 `OffsetDateTime`。
`ZonedDateTime`	`atZone(ZoneId zone)` 结合时间与时区来创建一个 `ZonedDateTime`。
`int`	`compareTo(ChronoLocalDateTime<?> other)` 将此日期时间与另一个日期时间进行比较。
`boolean`	`equals(Object obj)` 检查此日期时间是否等于另一个日期时间。
`String`	`format(DateTimeFormatter formatter)` 这个日期时间格式使用指定的格式化程序。
`static LocalDateTime`	`from(TemporalAccessor temporal)` 获得 `LocalDateTime`实例从一个时空对象。
`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()` 获取第二场的纳米。
`int`	`getSecond()` 获取第二个分钟字段。
`int`	`getYear()` 获取年度字段。
`int`	`hashCode()` 用于此日期时间的哈希代码。
`boolean`	`isAfter(ChronoLocalDateTime<?> other)` 检查此日期时间是否在指定日期时间之后。
`boolean`	`isBefore(ChronoLocalDateTime<?> other)` 检查此日期时间是否在指定日期时间之前。
`boolean`	`isEqual(ChronoLocalDateTime<?> other)` 检查此日期时间是否等于指定的日期时间。
`boolean`	`isSupported(TemporalField field)` 检查指定字段是否被支持。
`boolean`	`isSupported(TemporalUnit unit)` 检查指定的单位是否被支持。
`LocalDateTime`	`minus(long amountToSubtract, TemporalUnit unit)` 返回此日期时间的副本，用指定的金额减去。
`LocalDateTime`	`minus(TemporalAmount amountToSubtract)` 返回此日期时间的副本，用指定的金额减去。
`LocalDateTime`	`minusDays(long days)` 返回一份本 `LocalDateTime`与指定的期间天数减去。
`LocalDateTime`	`minusHours(long hours)` 返回一份本 `LocalDateTime`减去指定的时间在小时。
`LocalDateTime`	`minusMinutes(long minutes)` 返回一份本 `LocalDateTime`在几分钟之内减去指定的时间。
`LocalDateTime`	`minusMonths(long months)` 返回一份本 `LocalDateTime`与指定期个月减去。
`LocalDateTime`	`minusNanos(long nanos)` 返回一份本 `LocalDateTime`减去指定的时间在纳秒。
`LocalDateTime`	`minusSeconds(long seconds)` 返回一份本 `LocalDateTime`与指定期秒减去。
`LocalDateTime`	`minusWeeks(long weeks)` 返回一份本 `LocalDateTime`在周中减去指定的时间。
`LocalDateTime`	`minusYears(long years)` 返回一份本 `LocalDateTime`与指定期在年中减去。
`static LocalDateTime`	`now()` 从默认时区中的系统时钟中获取当前日期时间。
`static LocalDateTime`	`now(Clock clock)` 从指定的时钟中获取当前日期时间。
`static LocalDateTime`	`now(ZoneId zone)` 从指定时区中的系统时钟中获得当前日期时间。
`static LocalDateTime`	`of(int year, int month, int dayOfMonth, int hour, int minute)` 获得 `LocalDateTime`从年，月，日的一个实例，小时和分钟，设置第二和纳秒到零。
`static LocalDateTime`	`of(int year, int month, int dayOfMonth, int hour, int minute, int second)` 获得 `LocalDateTime`从年，月，日，小时，分钟和秒的实例，设置纳秒至零。
`static LocalDateTime`	`of(int year, int month, int dayOfMonth, int hour, int minute, int second, int nanoOfSecond)` 从今年的 `LocalDateTime`实例月，日，小时，分钟，秒和纳秒。
`static LocalDateTime`	`of(int year, Month month, int dayOfMonth, int hour, int minute)` 获得 `LocalDateTime`从年，月，日的一个实例，小时和分钟，设置第二和纳秒到零。
`static LocalDateTime`	`of(int year, Month month, int dayOfMonth, int hour, int minute, int second)` 获得 `LocalDateTime`从年，月，日，小时，分钟和秒的实例，设置纳秒至零。
`static LocalDateTime`	`of(int year, Month month, int dayOfMonth, int hour, int minute, int second, int nanoOfSecond)` 获得 `LocalDateTime`从年，月，日，小时，分钟的一个实例，二和纳秒。
`static LocalDateTime`	`of(LocalDate date, LocalTime time)` 获得 `LocalDateTime`实例的日期和时间。
`static LocalDateTime`	`ofEpochSecond(long epochSecond, int nanoOfSecond, ZoneOffset offset)` 获得由1970-01-01t00:00:00z时代秒 `LocalDateTime`实例。
`static LocalDateTime`	`ofInstant(Instant instant, ZoneId zone)` 获得 `LocalDateTime`实例从一个 `Instant`和区域ID。
`static LocalDateTime`	`parse(CharSequence text)` 获得 `LocalDateTime`实例从一个文本字符串，如 `2007-12-03T10:15:30`。
`static LocalDateTime`	`parse(CharSequence text, DateTimeFormatter formatter)` 获得 `LocalDateTime`实例从使用特定格式的文本字符串。
`LocalDateTime`	`plus(long amountToAdd, TemporalUnit unit)` 返回此日期时间的副本，添加指定的金额。
`LocalDateTime`	`plus(TemporalAmount amountToAdd)` 返回此日期时间的副本，添加指定的金额。
`LocalDateTime`	`plusDays(long days)` 返回一份本 `LocalDateTime`在天期间添加指定的。
`LocalDateTime`	`plusHours(long hours)` 返回一份本 `LocalDateTime`在指定时间内添加时间。
`LocalDateTime`	`plusMinutes(long minutes)` 返回一份本 `LocalDateTime`在几分钟之内指定期间补充。
`LocalDateTime`	`plusMonths(long months)` 返回一份本 `LocalDateTime`在月期添加指定的。
`LocalDateTime`	`plusNanos(long nanos)` 返回一份本 `LocalDateTime`在纳秒指定期间补充。
`LocalDateTime`	`plusSeconds(long seconds)` 返回一份本 `LocalDateTime`在指定时间内增加秒。
`LocalDateTime`	`plusWeeks(long weeks)` 返回一份本 `LocalDateTime`在周指定期间补充。
`LocalDateTime`	`plusYears(long years)` 返回一份本 `LocalDateTime`年指定期间补充。
`<R> R`	`query(TemporalQuery<R> query)` 使用指定的查询查询此日期时间。
`ValueRange`	`range(TemporalField field)` 获取指定字段的有效值的范围。
`LocalDate`	`toLocalDate()` 获取此日期时间的 `LocalDate`部分。
`LocalTime`	`toLocalTime()` 获取此日期时间的 `LocalTime`部分。
`String`	`toString()` 输出该日期时间为 `String`，如 `2007-12-03T10:15:30`。
`LocalDateTime`	`truncatedTo(TemporalUnit unit)` 返回一份本 `LocalDateTime`与定时。
`long`	`until(Temporal endExclusive, TemporalUnit unit)` 计算时间的量，直到指定单元的另一个日期时间。
`LocalDateTime`	`with(TemporalAdjuster adjuster)` 返回此日期时间的调整副本。
`LocalDateTime`	`with(TemporalField field, long newValue)` 将此日期时间的副本与指定的字段设置为一个新值。
`LocalDateTime`	`withDayOfMonth(int dayOfMonth)` 返回一份本 `LocalDateTime`与月改变的一天。
`LocalDateTime`	`withDayOfYear(int dayOfYear)` 返回一份本 `LocalDateTime`与天的年变化。
`LocalDateTime`	`withHour(int hour)` 返回一份本 `LocalDateTime`与一个值改变。
`LocalDateTime`	`withMinute(int minute)` 返回一份本 `LocalDateTime`与分钟小时值改变。
`LocalDateTime`	`withMonth(int month)` 返回一份本 `LocalDateTime`与月的年变化。
`LocalDateTime`	`withNano(int nanoOfSecond)` 返回一份本 `LocalDateTime`与纳米二值改变。
`LocalDateTime`	`withSecond(int second)` 返回一份本 `LocalDateTime`第二分钟值改变。
`LocalDateTime`	`withYear(int year)` 返回一份本 `LocalDateTime`与年变化。

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

Methods inherited from interface java.time.chrono.ChronoLocalDateTime
getChronology, timeLineOrder, toEpochSecond, toInstant

- Field Detail
  - MIN
```
public static final LocalDateTime MIN
```
    最小支持 LocalDateTime，”999999999 -01-01t00:00:00”。这是最低日期开始的午夜的本地日期时间。这将 LocalDate.MIN和 LocalTime.MIN。这可以通过一个应用程序作为一个“遥远的过去”的日期时间。
  - MAX
```
public static final LocalDateTime MAX
```
    所支持的最大 LocalDateTime，' + 999999999 -12-31t23:59:59. 999999999。这是当地日期时间才午夜结束时的最大日期。这将 LocalDate.MAX和 LocalTime.MAX。这可以通过一个应用程序作为一个“远景”日期时间。
- 方法详细信息
  - now
```
public static LocalDateTime now()
```
    从默认时区中的系统时钟中获取当前日期时间。
    这将查询system clock在默认时区获取当前日期时间。
    
    使用这种方法将防止使用另一个时钟进行测试的能力，因为时钟是硬编码的。
    
    结果
    
    当前日期时间使用系统时钟和默认时区，而不是空
  - now
```
public static LocalDateTime now(ZoneId zone)
```
    从指定时区中的系统时钟中获得当前日期时间。
    这将查询system clock获得当前的日期时间。指定时区避免依赖于默认时区。
    
    使用这种方法将防止使用另一个时钟进行测试的能力，因为时钟是硬编码的。
    
    参数
    
    zone -区ID使用，不为空
    
    结果
    
    当前日期时间使用系统时钟，而不是空
  - now
```
public static LocalDateTime now(Clock clock)
```
    从指定的时钟中获取当前日期时间。
    这将查询指定的时钟，以获得当前日期时间。使用这种方法允许使用一个备用时钟进行测试。备用时钟可采用dependency injection。
    
    参数
    
    clock -时钟使用，不为空
    
    结果
    
    当前日期时间，而不是空
  - of
```
public static LocalDateTime of(int year,
                               Month month,
                               int dayOfMonth,
                               int hour,
                               int minute)
```
    获得 LocalDateTime从年，月，日的一个实例，小时和分钟，设置第二和纳秒到零。
    返回具有指定年、月LocalDateTime，日期，小时和分钟。一天必须是有效的，因为一年和一个月，否则将抛出异常。第二个和纳秒级的字段将被设置为零。
    
    参数
    
    year年的代表，从min_year到max_year
    
    month -年月表示，不为空
    
    dayOfMonth -月代表天，从1到31
    
    hour -天代表小时，从0到23
    
    minute -小时代表分钟，从0到59
    
    结果
    
    本地日期时间，而不是空
    
    异常
    
    DateTimeException -如果任何字段的值超出范围，或如果月日年月日是无效的
  - of
```
public static LocalDateTime of(int year,
                               Month month,
                               int dayOfMonth,
                               int hour,
                               int minute,
                               int second)
```
    获得 LocalDateTime从年，月，日，小时，分钟和秒的实例，设置纳秒至零。
    返回具有指定年、月LocalDateTime，日期，小时，分钟和秒。一天必须是有效的，因为一年和一个月，否则将抛出异常。纳秒级场将被设置为零。
    
    参数
    
    year年的代表，从min_year到max_year
    
    month -年月表示，不为空
    
    dayOfMonth -月代表天，从1到31
    
    hour -天代表小时，从0到23
    
    minute -小时代表分钟，从0到59
    
    second -二分为代表，从0到59
    
    结果
    
    本地日期时间，而不是空
    
    异常
    
    DateTimeException -如果任何字段的值超出范围，或如果月日年月日是无效的
  - of
```
public static LocalDateTime of(int year,
                               Month month,
                               int dayOfMonth,
                               int hour,
                               int minute,
                               int second,
                               int nanoOfSecond)
```
    获得 LocalDateTime从年，月，日，小时，分钟的一个实例，二和纳秒。
    返回具有指定年、月LocalDateTime，日期，小时，分钟，秒和纳秒。一天必须是有效的，因为一年和一个月，否则将抛出异常。
    
    参数
    
    year年的代表，从min_year到max_year
    
    month -年月表示，不为空
    
    dayOfMonth -月代表天，从1到31
    
    hour -天代表小时，从0到23
    
    minute -小时代表分钟，从0到59
    
    second -二分为代表，从0到59
    
    nanoOfSecond -二代表纳米，从0到999999999
    
    结果
    
    本地日期时间，而不是空
    
    异常
    
    DateTimeException -如果任何字段的值超出范围，或如果月日年月日是无效的
  - of
```
public static LocalDateTime of(int year,
                               int month,
                               int dayOfMonth,
                               int hour,
                               int minute)
```
    获得 LocalDateTime从年，月，日的一个实例，小时和分钟，设置第二和纳秒到零。
    返回具有指定年、月LocalDateTime，日期，小时和分钟。一天必须是有效的，因为一年和一个月，否则将抛出异常。第二个和纳秒级的字段将被设置为零。
    
    参数
    
    year年的代表，从min_year到max_year
    
    month -年月为代表，从1（一月）到12（十二月）
    
    dayOfMonth -月代表天，从1到31
    
    hour -天代表小时，从0到23
    
    minute -小时代表分钟，从0到59
    
    结果
    
    本地日期时间，而不是空
    
    异常
    
    DateTimeException -如果任何字段的值超出范围，或如果月日年月日是无效的
  - of
```
public static LocalDateTime of(int year,
                               int month,
                               int dayOfMonth,
                               int hour,
                               int minute,
                               int second)
```
    获得 LocalDateTime从年，月，日，小时，分钟和秒的实例，设置纳秒至零。
    返回具有指定年、月LocalDateTime，日期，小时，分钟和秒。一天必须是有效的，因为一年和一个月，否则将抛出异常。纳秒级场将被设置为零。
    
    参数
    
    year年的代表，从min_year到max_year
    
    month -年月为代表，从1（一月）到12（十二月）
    
    dayOfMonth -月代表天，从1到31
    
    hour -天代表小时，从0到23
    
    minute -小时代表分钟，从0到59
    
    second -二分为代表，从0到59
    
    结果
    
    本地日期时间，而不是空
    
    异常
    
    DateTimeException -如果任何字段的值超出范围，或如果月日年月日是无效的
  - of
```
public static LocalDateTime of(int year,
                               int month,
                               int dayOfMonth,
                               int hour,
                               int minute,
                               int second,
                               int nanoOfSecond)
```
    获得 LocalDateTime从年，月，日，小时，分钟的一个实例，二和纳秒。
    返回具有指定年、月LocalDateTime，日期，小时，分钟，秒和纳秒。一天必须是有效的，因为一年和一个月，否则将抛出异常。
    
    参数
    
    year年的代表，从min_year到max_year
    
    month -年月为代表，从1（一月）到12（十二月）
    
    dayOfMonth -月代表天，从1到31
    
    hour -天代表小时，从0到23
    
    minute -小时代表分钟，从0到59
    
    second -二分为代表，从0到59
    
    nanoOfSecond -二代表纳米，从0到999999999
    
    结果
    
    本地日期时间，而不是空
    
    异常
    
    DateTimeException -如果任何字段的值超出范围，或如果月日年月日是无效的
  - of
```
public static LocalDateTime of(LocalDate date,
                               LocalTime time)
```
    获得 LocalDateTime实例的日期和时间。
    
    参数
    
    date -本地日期，不为空
    
    time -当地时间，不空
    
    结果
    
    本地日期时间，而不是空
  - ofInstant
```
public static LocalDateTime ofInstant(Instant instant,
                                      ZoneId zone)
```
    获得 LocalDateTime实例从一个 Instant和
    这将创建一个基于指定的即时的本地日期时间。首先，从UTC /格林尼治胶印是利用带ID和即时获得，这很简单，对于每个时刻只有一个有效的抵消。然后，使用即时和偏移来计算本地日期时间。
    区ID。
    
    参数
    
    instant -创建日期时间的瞬间，不为空
    
    zone的时区，这可能是一个偏移量，不为空
    
    结果
    
    本地日期时间，而不是空
    
    异常
    
    DateTimeException -如果结果超过支持的范围
  - ofEpochSecond
```
public static LocalDateTime ofEpochSecond(long epochSecond,
                                          int nanoOfSecond,
                                          ZoneOffset offset)
```
    获得由1970-01-01t00:00:00z时代秒 LocalDateTime
    这让epoch-second场被转换为本地时间。这主要是用于低级别的转换，而不是一般的应用程序使用。
    实例。
    
    参数
    
    epochSecond从1970-01-01t00:00:00z时代的秒数
    
    nanoOfSecond在二纳秒级，从0到999999999
    
    offset -区偏移，不空
    
    结果
    
    本地日期时间，而不是空
    
    异常
    
    DateTimeException -如果结果超过支持的范围，或者二纳米是无效的
  - from
```
public static LocalDateTime from(TemporalAccessor temporal)
```
    获得 LocalDateTime实例从一个时空对象。
    这将获得一个基于指定时间的偏移时间。一个TemporalAccessor表示日期和时间信息，任意设置，本厂将以LocalDateTime实例。
    
    转换提取物结合LocalDate从时空对象的LocalTime。实现允许执行优化，如访问这些字段，这些字段相当于相关对象。
    
    这种方法相匹配的功能接口TemporalQuery可以通过方法引用查询的签名，LocalDateTime::from。
    
    Specified by:
    
    from 接口 ChronoLocalDateTime<LocalDate>
    
    参数
    
    temporal -转换时间的对象，不为空
    
    结果
    
    本地日期时间，而不是空
    
    异常
    
    DateTimeException如果无法转换为 LocalDateTime
    
    另请参见：
    
    Chronology.localDateTime(TemporalAccessor)
  - parse
```
public static LocalDateTime parse(CharSequence text)
```
    获得 LocalDateTime实例从一个文本字符串，如 2007-12-03T10:15:30。
    该字符串必须是一个有效的日期时间和使用DateTimeFormatter.ISO_LOCAL_DATE_TIME解析。
    
    参数
    
    text -文本解析如“2007-12-03t10:15:30”，不为空
    
    结果
    
    解析的本地日期时间，而不是空
    
    异常
    
    DateTimeParseException如果文本不能解析
  - parse
```
public static LocalDateTime parse(CharSequence text,
                                  DateTimeFormatter formatter)
```
    获得 LocalDateTime实例从使用特定格式的文本字符串。
    文字使用格式化程序解析，返回一个日期时间。
    
    参数
    
    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
    所有其他 ChronoField实例将返回false。
    如果该字段是不是ChronoField，然后通过调用作为参数传递this TemporalField.isSupportedBy(TemporalAccessor)得到此方法的结果。是否支持字段由字段确定。
    Specified by:
    
    isSupported 接口 ChronoLocalDateTime<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 接口 ChronoLocalDateTime<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 接口 TemporalAccessor
    
    参数
    
    field -现场查询范围，不为空
    
    结果
    
    字段的有效值的范围，而不是空值
    
    异常
    
    DateTimeException如果不能得到的领域范围
    
    UnsupportedTemporalTypeException如果字段不支持
  - get
```
public int get(TemporalField field)
```
    从这个日期时间作为一个 int获取指定字段的值。
    此查询此日期时间为指定字段的值。返回的值将始终在字段的有效值范围内。如果不可能返回值，因为字段不支持或其他原因，则抛出异常。
    
    如果该字段是ChronoField然后查询执行。的supported fields将基于此日期时间、有效值除NANO_OF_DAY，MICRO_OF_DAY，EPOCH_DAY和PROLEPTIC_MONTH太大，安装在一个int、扔DateTimeException。所有其他ChronoField实例将抛出一个UnsupportedTemporalTypeException。
    
    如果该字段是不是ChronoField，然后通过调用作为参数传递this TemporalField.getFrom(TemporalAccessor)得到此方法的结果。是否可以得到值，以及值表示的值，由字段确定。
    
    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 接口 TemporalAccessor
    
    参数
    
    field -领域有，不空
    
    结果
    
    字段的值
    
    异常
    
    DateTimeException如果不能得到一个价值领域
    
    UnsupportedTemporalTypeException如果字段不支持
    
    ArithmeticException如果数值溢出时
  - toLocalDate
```
public LocalDate toLocalDate()
```
    获取此日期时间的 LocalDate部分。
    这将返回一个与当年LocalDate，月日这个日期时间。
    
    Specified by:
    
    toLocalDate 接口 ChronoLocalDateTime<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 接口 ChronoLocalDateTime<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 LocalDateTime with(TemporalAdjuster adjuster)
```
    返回此日期时间的调整副本。
    这将返回一个LocalDateTime，基于此，与日期时间调整。调整使用指定的调整器策略对象。阅读调整器的文档，了解将要做什么调整。
    
    一个简单的调节器可以简单地设置一个字段，例如年字段。一个更复杂的调节器可能会把日期定在月的最后一天。选择常见的调整提供了TemporalAdjuster。这些包括找到“一个月的最后一天”和“下星期三”。关键日期时间类也实现TemporalAdjuster接口，如Month和MonthDay。调节器负责处理特殊情况，如不同长度的月份和闰年。
    
    例如，此代码在七月的最后一天返回日期：
```
进口静态java。时间。月。*；进口静态java。时间。时间。调节。*；结果：localdatetime，（七月），（lastdayofmonth()）；
```
    这类LocalDate和LocalTime实施TemporalAdjuster，因此该方法可用于更改日期、时间或偏移：
```
结果：localdatetime与（日期）；结果：localdatetime与（时间）；
```
    这种方法的结果是通过调用指定的调节器，通过this作为论据的TemporalAdjuster.adjustInto(Temporal)方法得到的。
    
    此实例是不可变的，不受此方法调用的影响。
    Specified by:
    
    with 接口 ChronoLocalDateTime<LocalDate>
    
    Specified by:
    
    with 接口 Temporal
    
    参数
    
    adjuster -调节器使用，不为空
    
    结果
    
    一个 LocalDateTime基于调整 this，不空
    
    异常
    
    DateTimeException -如果调整不能
    
    ArithmeticException如果数值溢出时
  - with
```
public LocalDateTime with(TemporalField field,
                          long newValue)
```
    将此日期时间的副本与指定的字段设置为一个新值。
    这将返回一个LocalDateTime，在此基础上，对指定字段的值的变化。这可以用来改变任何支持的领域，如一年，一个月或一天的月。如果不可能设置值，因为字段不支持或其他原因，则抛出异常。
    
    在某些情况下，更改指定的字段会导致结果的日期时间无效，如更改从1月31日至二月的月将使月无效的日期无效。在这样的情况下，该字段是负责解决日期。通常情况下，它会选择以前的有效日期，这将是二月的最后一个有效的一天，在这个例子中。
    
    如果该字段是ChronoField然后调整在这里实现。的supported fields将表现为每个匹配的方法LocalDate或LocalTime。所有其他ChronoField实例将抛出一个UnsupportedTemporalTypeException。
    
    如果该字段是不是ChronoField，然后通过调用作为参数传递this TemporalField.adjustInto(Temporal, long)得到此方法的结果。在这种情况下，字段决定是否以及如何调整即时。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    with 接口 ChronoLocalDateTime<LocalDate>
    
    Specified by:
    
    with 接口 Temporal
    
    参数
    
    field -现场设置的结果，不为空
    
    newValue -场的结果中的新价值
    
    结果
    
    一个 LocalDateTime基于指定的字段集 this，不空
    
    异常
    
    DateTimeException -如果该字段不能设置
    
    UnsupportedTemporalTypeException如果字段不支持
    
    ArithmeticException如果数值溢出时
  - withYear
```
public LocalDateTime withYear(int year)
```
    返回一份本 LocalDateTime与年变化。时间不影响计算，结果与计算结果是一致的。如果一个月的一天是无效的，它将被更改为月的最后一个有效的一天。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    year年设置的结果，从min_year到max_year
    
    结果
    
    基于这一 LocalDateTime日期时间与请求的一年，不为空
    
    异常
    
    DateTimeException如果年值无效
  - withMonth
```
public LocalDateTime withMonth(int month)
```
    返回一份本 LocalDateTime与月的年变化。时间不影响计算，结果与计算结果是一致的。如果一个月的一天是无效的，它将被更改为月的最后一个有效的一天。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    month -年月在结果集，从1（一月）到12（十二月）
    
    结果
    
    基于这一 LocalDateTime日期时间与请求的月，不为空
    
    异常
    
    DateTimeException如果年值月是无效的
  - withDayOfMonth
```
public LocalDateTime withDayOfMonth(int dayOfMonth)
```
    返回一份本 LocalDateTime与月改变的一天。如果得到的 LocalDateTime无效，则抛出一个异常。时间不影响计算，结果与计算结果是一致的。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    dayOfMonth -月在结果集的一天，从1至28
    
    结果
    
    基于这一 LocalDateTime日期时间与请求的天，不是空的
    
    异常
    
    DateTimeException如果月值一天是无效的，或者如果月日年月日是无效的
  - withDayOfYear
```
public LocalDateTime withDayOfYear(int dayOfYear)
```
    返回一份本 LocalDateTime与天的年变化。如果得到的 LocalDateTime无效，则抛出一个异常。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    dayOfYear -一年建立在结果的那一天，从1到杂志
    
    结果
    
    与请求日这一天 LocalDateTime为主，不为空
    
    异常
    
    DateTimeException如果年值一天是无效的，或者如果一天今年是无效的
  - withHour
```
public LocalDateTime withHour(int hour)
```
    返回一份本 LocalDateTime与一个值改变。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    hour -天时设置的结果，从0到23
    
    结果
    
    基于这一 LocalDateTime日期时间与请求的时辰，不空
    
    异常
    
    DateTimeException -如果时间值无效
  - withMinute
```
public LocalDateTime withMinute(int minute)
```
    返回一份本 LocalDateTime与分钟小时值改变。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    minute -小时设置在结果的那一刻，从0到59
    
    结果
    
    基于这一 LocalDateTime日期时间与请求的一分钟，不为空
    
    异常
    
    DateTimeException如果分钟值无效
  - withSecond
```
public LocalDateTime withSecond(int second)
```
    返回一份本 LocalDateTime第二分钟值改变。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    second -二分钟设置的结果，从0到59
    
    结果
    
    基于这一 LocalDateTime日期时间与请求的第二，不空
    
    异常
    
    DateTimeException如果二值无效
  - withNano
```
public LocalDateTime withNano(int nanoOfSecond)
```
    返回一份本 LocalDateTime与纳米二值改变。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    nanoOfSecond -二设置结果纳米，从0到999999999
    
    结果
    
    基于这一 LocalDateTime日期时间与请求的纳秒，不空
    
    异常
    
    DateTimeException如果纳米值无效
  - truncatedTo
```
public LocalDateTime truncatedTo(TemporalUnit unit)
```
    返回一份本 LocalDateTime与定时。
    截断返回原始日期时间的副本，该字段小于指定的单位设置为零的字段。例如，截断与minutes单元组分，第二场零纳米二。
    
    单位必须有一个duration分成标准节长度无余。这包括所有提供的时间单位ChronoUnit和DAYS。其他单位抛出一个异常。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    unit -单位截形，不为空
    
    结果
    
    基于这一 LocalDateTime日期时间与时间截断，不空
    
    异常
    
    DateTimeException如果无法截断
    
    UnsupportedTemporalTypeException如果字段不支持
  - plus
```
public LocalDateTime plus(TemporalAmount amountToAdd)
```
    返回此日期时间的副本，添加指定的金额。
    这将返回一个LocalDateTime，在此基础上，用指定的添加量。量通常是Period或Duration但可能是任何其他类型的TemporalAmount接口实现。
    
    计算委托量对象通过调用TemporalAmount.addTo(Temporal)。执行金额是免费在任何情况下它的愿望实现，但是它通常称为回plus(long, TemporalUnit)。咨询金额实现的文档，以确定是否可以成功添加。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    plus 接口 ChronoLocalDateTime<LocalDate>
    
    Specified by:
    
    plus 接口 Temporal
    
    参数
    
    amountToAdd -添加量，不为空
    
    结果
    
    基于这一 LocalDateTime日期时间的增加，不为空
    
    异常
    
    DateTimeException如果还不能
    
    ArithmeticException如果数值溢出时
  - plus
```
public LocalDateTime plus(long amountToAdd,
                          TemporalUnit unit)
```
    返回此日期时间的副本，添加指定的金额。
    这将返回一个LocalDateTime，基于此，在单元的添加量。如果它是不可能添加的量，因为该单元不支持或其他原因，则抛出异常。
    
    如果该字段是ChronoUnit然后添加在这里实现。日期单元添加每LocalDate.plus(long, TemporalUnit)。时间单位是作为每LocalTime.plus(long, TemporalUnit)在天任何溢出增加相当于使用plusDays(long)。
    
    如果该字段是不是ChronoUnit，然后通过调用作为参数传递this TemporalUnit.addTo(Temporal, long)得到此方法的结果。在这种情况下，该单元确定是否和如何执行加法。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    plus 接口 ChronoLocalDateTime<LocalDate>
    
    Specified by:
    
    plus 接口 Temporal
    
    参数
    
    amountToAdd -单位的数量增加的结果，可能是负面的
    
    添加 unit -量的单位，不为空
    
    结果
    
    基于这一 LocalDateTime日期与指定的添加量，不为空
    
    异常
    
    DateTimeException如果还不能
    
    UnsupportedTemporalTypeException如果单位不支持
    
    ArithmeticException如果数值溢出时
  - plusYears
```
public LocalDateTime plusYears(long years)
```
    返回一份本 LocalDateTime年指定期间补充。
    此方法将指定的金额添加到三个步骤中的年字段中：
    1. 添加输入年到年字段
    2. 检查结果日期是否无效
    3. 调整一个月的一天，如果必要的话，最后一个有效的一天
    例如，2008-02-29（闰年）加一年会导致无效的日期2009-02-29（标准年）。而不是返回一个无效的结果，最后一日的一个月，2009-02-28所代替。
    
    此实例是不可变的，不受此方法调用的影响。
    参数
    
    years -加年，可能是负面的
    
    结果
    
    基于这一 LocalDateTime日期时间与年增加，不为空
    
    异常
    
    DateTimeException -如果结果超过支持的日期范围
  - plusMonths
```
public LocalDateTime plusMonths(long months)
```
    返回一份本 LocalDateTime在月期添加指定的。
    此方法在三个步骤中添加指定的金额到月字段中：
    1. 添加输入月到年字段
    2. 检查结果日期是否无效
    3. 调整一个月的一天，如果必要的话，最后一个有效的一天
    例如，2007-03-31加一个月会导致无效的日期2007-04-31。而不是返回一个无效的结果，最后一日的一个月，2007-04-30所代替。
    
    此实例是不可变的，不受此方法调用的影响。
    参数
    
    months -加个月，可能是负面的
    
    结果
    
    基于这一 LocalDateTime日期时间与月说，不空
    
    异常
    
    DateTimeException -如果结果超过支持的日期范围
  - plusWeeks
```
public LocalDateTime plusWeeks(long weeks)
```
    返回一份本 LocalDateTime在周指定期间补充。
    此方法将指定数量的天场周递增的月和年等要保证结果仍然有效。如果超出最大/最小年，则结果是无效的。
    
    例如，2008-12-31加一周会导致2009-01-07。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    weeks -加周，可能是负面的
    
    结果
    
    基于这一 LocalDateTime日期时间与周说，不空
    
    异常
    
    DateTimeException -如果结果超过支持的日期范围
  - plusDays
```
public LocalDateTime plusDays(long days)
```
    返回一份本 LocalDateTime在天期间添加指定的。
    该方法将指定数量的天场递增的年和月的领域要保证结果仍然有效。如果超出最大/最小年，则结果是无效的。
    
    例如，2008-12-31加一天会导致一。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    days -添加的日子，可能是负面的
    
    结果
    
    基于这一 LocalDateTime日期时间与天添加，不为空
    
    异常
    
    DateTimeException -如果结果超过支持的日期范围
  - plusHours
```
public LocalDateTime plusHours(long hours)
```
    返回一份本 LocalDateTime在指定时间内添加时间。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    hours -添加时间，可能是负面的
    
    结果
    
    基于这一 LocalDateTime日期与时间增加，不为空
    
    异常
    
    DateTimeException -如果结果超过支持的日期范围
  - plusMinutes
```
public LocalDateTime plusMinutes(long minutes)
```
    返回一份本 LocalDateTime在几分钟之内指定期间补充。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    minutes -添加记录，可能是负面的
    
    结果
    
    基于这一 LocalDateTime日期时间与增加分钟，不空
    
    异常
    
    DateTimeException -如果结果超过支持的日期范围
  - plusSeconds
```
public LocalDateTime plusSeconds(long seconds)
```
    返回一份本 LocalDateTime在指定时间内增加秒。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    seconds -加秒，可能是负面的
    
    结果
    
    基于这一 LocalDateTime日期时间用秒说，不空
    
    异常
    
    DateTimeException -如果结果超过支持的日期范围
  - plusNanos
```
public LocalDateTime plusNanos(long nanos)
```
    返回一份本 LocalDateTime在纳秒指定期间补充。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    nanos -添加纳米，可能是负面的
    
    结果
    
    基于这一 LocalDateTime日期时间与纳秒补充道，不空
    
    异常
    
    DateTimeException -如果结果超过支持的日期范围
  - minus
```
public LocalDateTime minus(TemporalAmount amountToSubtract)
```
    返回此日期时间的副本，用指定的金额减去。
    这将返回一个LocalDateTime，在此基础上，用指定的金额减去。量通常是Period或Duration但可能是任何其他类型的TemporalAmount接口实现。
    
    计算委托量对象通过调用TemporalAmount.subtractFrom(Temporal)数量，实现自由以任何方式希望实现减法，但它通常需要回minus(long, TemporalUnit)。咨询文档的量的实现，以确定它是否可以成功地减去。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    minus 接口 ChronoLocalDateTime<LocalDate>
    
    Specified by:
    
    minus 接口 Temporal
    
    参数
    
    amountToSubtract -减去的量，不为空
    
    结果
    
    基于这一 LocalDateTime日期时间的减法，不空
    
    异常
    
    DateTimeException如果减法不能做
    
    ArithmeticException如果数值溢出时
  - minus
```
public LocalDateTime minus(long amountToSubtract,
                           TemporalUnit unit)
```
    返回此日期时间的副本，用指定的金额减去。
    这将返回一个LocalDateTime，在此基础上，对单位金额减去。如果它是不可能的减去的量，因为该单位不支持或一些其他原因，一个异常被抛出。
    
    这种方法相当于plus(long, TemporalUnit)量与否定。见该方法充分说明了如何加法，从而减法，作品。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    minus 接口 ChronoLocalDateTime<LocalDate>
    
    Specified by:
    
    minus 接口 Temporal
    
    参数
    
    amountToSubtract -减去从结果数额的单位，可能是负面的
    
    unit -金额单位减，不为空
    
    结果
    
    基于这一 LocalDateTime日期与指定的金额中减去，不空
    
    异常
    
    DateTimeException如果减法不能做
    
    UnsupportedTemporalTypeException如果单位不支持
    
    ArithmeticException如果数值溢出时
  - minusYears
```
public LocalDateTime minusYears(long years)
```
    返回一份本 LocalDateTime与指定期在年中减去。
    该方法中减去指定的金额从三步来场：
    1. 减去年内输入的年份
    2. 检查结果日期是否无效
    3. 调整一个月的一天，如果必要的话，最后一个有效的一天
    例如，2008-02-29（闰年）减去一年会导致无效的日期2009-02-29（标准年）。而不是返回一个无效的结果，最后一日的一个月，2009-02-28所代替。
    
    此实例是不可变的，不受此方法调用的影响。
    参数
    
    years -减去年，可能是负面的
    
    结果
    
    基于这一 LocalDateTime日期时间与年中减去，不空
    
    异常
    
    DateTimeException -如果结果超过支持的日期范围
  - minusMonths
```
public LocalDateTime minusMonths(long months)
```
    返回一份本 LocalDateTime与指定期个月减去。
    该方法中减去指定的金额从三步月场：
    1. 从一个月的一个月的字段减去输入月
    2. 检查结果日期是否无效
    3. 调整一个月的一天，如果必要的话，最后一个有效的一天
    例如，2007-03-31减去一个月会导致无效的日期2007-04-31。而不是返回一个无效的结果，最后一日的一个月，2007-04-30所代替。
    
    此实例是不可变的，不受此方法调用的影响。
    参数
    
    months -减去个月，可能是负面的
    
    结果
    
    基于这一 LocalDateTime日期时间与月减去，不空
    
    异常
    
    DateTimeException -如果结果超过支持的日期范围
  - minusWeeks
```
public LocalDateTime minusWeeks(long weeks)
```
    返回一份本 LocalDateTime在周中减去指定的时间。
    该方法在周中减去指定的金额从天场递减的年份和月份等要保证结果仍然有效。如果超出最大/最小年，则结果是无效的。
    
    例如，2009-01-07减去一周会导致2008-12-31。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    weeks -减去的数周，可能是负面的
    
    结果
    
    基于这一 LocalDateTime日期与星期减去，不空
    
    异常
    
    DateTimeException -如果结果超过支持的日期范围
  - minusDays
```
public LocalDateTime minusDays(long days)
```
    返回一份本 LocalDateTime与指定的期间天数减去。
    该方法中减去指定的金额从天场递增的年和月的领域要保证结果仍然有效。如果超出最大/最小年，则结果是无效的。
    
    例如，一减一天会导致2008-12-31。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    days -减去几天，可能是负面的
    
    结果
    
    基于这一 LocalDateTime日期时间与天减去，不空
    
    异常
    
    DateTimeException -如果结果超过支持的日期范围
  - minusHours
```
public LocalDateTime minusHours(long hours)
```
    返回一份本 LocalDateTime减去指定的时间在小时。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    hours -减小时，可能是负面的
    
    结果
    
    基于这一 LocalDateTime日期时间与时间中减去，不空
    
    异常
    
    DateTimeException -如果结果超过支持的日期范围
  - minusMinutes
```
public LocalDateTime minusMinutes(long minutes)
```
    返回一份本 LocalDateTime在几分钟之内减去指定的时间。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    minutes -减分，可能是负面的
    
    结果
    
    基于这一 LocalDateTime日期时间以分钟减去，不空
    
    异常
    
    DateTimeException -如果结果超过支持的日期范围
  - minusSeconds
```
public LocalDateTime minusSeconds(long seconds)
```
    返回一份本 LocalDateTime与指定期秒减去。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    seconds -减去秒，可能是负面的
    
    结果
    
    基于这一 LocalDateTime日期时间与秒减去，不空
    
    异常
    
    DateTimeException -如果结果超过支持的日期范围
  - minusNanos
```
public LocalDateTime minusNanos(long nanos)
```
    返回一份本 LocalDateTime减去指定的时间在纳秒。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    nanos -减去这些可能是负面的
    
    结果
    
    基于这一 LocalDateTime日期时间与纳秒减去，不空
    
    异常
    
    DateTimeException -如果结果超过支持的日期范围
  - query
```
public <R> R query(TemporalQuery<R> query)
```
    使用指定的查询查询此日期时间。
    此查询使用指定的查询策略对象使用此日期时间。的TemporalQuery对象定义了用来获得结果的逻辑。阅读查询的文档，了解该方法的结果将是什么。
    
    这种方法的结果是通过调用指定的查询通过this作为论据的TemporalQuery.queryFrom(TemporalAccessor)方法得到的。
    
    Specified by:
    
    query 接口 ChronoLocalDateTime<LocalDate>
    
    Specified by:
    
    query 接口 TemporalAccessor
    
    参数类型
    
    R -结果的类型
    
    参数
    
    query -调用查询，不空
    
    结果
    
    查询结果，可以返回（由查询所定义）
    
    异常
    
    DateTimeException如果无法查询（查询所定义）
    
    ArithmeticException如果数值溢出时（由查询定义）
  - adjustInto
```
public Temporal adjustInto(Temporal temporal)
```
    调整指定的时间对象，以具有相同的日期和时间为对象。
    这将返回一个相同的可观察类型的时间对象，作为输入的日期和时间改变了，这是相同的。
    
    调整是相当于用Temporal.with(TemporalField, long)两次，通过ChronoField.EPOCH_DAY和ChronoField.NANO_OF_DAY的领域。
    
    在大多数情况下，更清晰的用Temporal.with(TemporalAdjuster)反向调用模式：
```
这两条线是等价的，但第二种方法是建议时间= thislocaldatetime adjustinto（时间）；时间=（thislocaldatetime）与时间；
```
    此实例是不可变的，不受此方法调用的影响。
    Specified by:
    
    adjustInto 接口 ChronoLocalDateTime<LocalDate>
    
    Specified by:
    
    adjustInto 接口 TemporalAdjuster
    
    参数
    
    temporal -调整目标对象，不为空
    
    结果
    
    调整后的对象，而不是空
    
    异常
    
    DateTimeException如果无法适应
    
    ArithmeticException如果数值溢出时
  - until
```
public long until(Temporal endExclusive,
                  TemporalUnit unit)
```
    计算时间的量，直到指定单元的另一个日期时间。
    这两LocalDateTime计算对象之间的时间量在一个TemporalUnit条款。开始和结束点this和指定的日期时间。结果将是负的，如果结束之前开始。的Temporal传递给此方法转换为LocalDateTime使用from(TemporalAccessor)。例如，两个日期时间之间的天数可以计算使用量startDateTime.until(endDateTime, DAYS)。
    
    计算返回一个整数，表示两个日期之间的完整单元的数目。例如，在2012-06-15t00:00和2012-08-14t23:59之间月量将只有一个月很短，两个月一分钟。
    
    使用这种方法有两个等效的方法。首先是调用这个方法。二是用TemporalUnit.between(Temporal, Temporal)：
```
这两条线是等价的金额=开始，直到（结束，月）；金额=月间（开始，结束）；
```
    的选择应基于使得代码更易读。
    计算中实现该方法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 -结束日期，排斥，这是转化为一个 LocalDateTime，不空
    
    unit -单位量来衡量，不为空
    
    结果
    
    这个日期时间和结束日期时间之间的时间
    
    异常
    
    DateTimeException如果金额无法计算，或结束时间不能转换为 LocalDateTime
    
    UnsupportedTemporalTypeException如果单位不支持
    
    ArithmeticException如果数值溢出时
  - format
```
public String format(DateTimeFormatter formatter)
```
    这个日期时间格式使用指定的格式化程序。
    这个日期将被传递到格式化程序产生一个字符串。
    
    Specified by:
    
    format 接口 ChronoLocalDateTime<LocalDate>
    
    参数
    
    formatter -格式化程序使用，不为空
    
    结果
    
    格式化的日期时间字符串，而不是空的
    
    异常
    
    DateTimeException如果打印时发生错误
  - atOffset
```
public OffsetDateTime atOffset(ZoneOffset offset)
```
    结合这个日期时间偏移来创建一个 OffsetDateTime。
    返回由这个日期时间的指定偏移量处OffsetDateTime。日期时间和偏移的所有可能的组合都是有效的。
    
    参数
    
    offset -偏移结合，不为空
    
    结果
    
    从这个日期时间和指定的偏移量所形成的偏移日期时间，而不是空值
  - atZone
```
public ZonedDateTime atZone(ZoneId zone)
```
    结合时间与时区来创建一个 ZonedDateTime。
    这会返回一个由这个日期时间在指定的时区ZonedDateTime。其结果将与此日期时间尽可能紧密地匹配。时间区域规则，如日光节约，意味着不是每个本地日期时间都是有效的指定区域，因此本地日期时间可以调整。
    
    本地日期时间解决在时间线上的一个单一时刻上。这是通过寻找从UTC /格林尼治本地日期时间的区域ID。rules定义有效的抵消了
    
    在大多数情况下，只有一个本地日期时间的有效偏移量。在重叠的情况下，时钟被设置回来，有两个有效的偏移量。此方法使用较早的偏移量，通常对应于“夏季”。
    
    在一个差距的情况下，时钟跳向前，没有有效的偏移。相反，本地日期时间被调整为稍后的差距的长度。对于一个典型的一小时的日光节约变化，当地日期时间将移动一个小时后到偏移通常对应于“夏天”。
    
    得到后偏移在重叠，调用该方法的结果ZonedDateTime.withLaterOffsetAtOverlap()。抛出一个异常时有间隙或重叠，使用ZonedDateTime.ofStrict(LocalDateTime, ZoneOffset, ZoneId)。
    
    Specified by:
    
    atZone 接口 ChronoLocalDateTime<LocalDate>
    
    参数
    
    zone -时区使用，不为空
    
    结果
    
    从这个日期时间形成的分区日期时间，而不是空
  - compareTo
```
public int compareTo(ChronoLocalDateTime<?> other)
```
    将此日期时间与另一个日期时间进行比较。
    比较主要是基于日期时间，从最早到最新的。这是“等于”一致，所定义的Comparable。
    
    如果所有的日期时间比较LocalDateTime实例比较，然后将完全根据日期时间。如果一些日期比较在不同的年表，那么时间也被认为是，看到ChronoLocalDateTime.compareTo(java.time.chrono.ChronoLocalDateTime<?>)。
    
    Specified by:
    
    compareTo 接口 Comparable<ChronoLocalDateTime<?>>
    
    Specified by:
    
    compareTo 接口 ChronoLocalDateTime<LocalDate>
    
    参数
    
    other的其他时间相比，不空
    
    结果
    
    比较器的值，负的，如果少，积极的，如果更大
  - isAfter
```
public boolean isAfter(ChronoLocalDateTime<?> other)
```
    检查此日期时间是否在指定日期时间之后。
    此检查查看此日期时间是否代表另一个日期时间后的本地时间线的一个点。
```
localdate = localdatetime，（2012，6，30，12，00）；localdate B = localdatetime，（2012，7，1，12，00）；a.isafter（B）= =假a.isafter（一）= =假b.isafter（一）= =真
```
    此方法只考虑在本地时间线上的两个日期时间的位置。它没有考虑到年代，或日历系统。这是不同于compareTo(ChronoLocalDateTime)比较，但跟ChronoLocalDateTime.timeLineOrder()相同。
    Specified by:
    
    isAfter 接口 ChronoLocalDateTime<LocalDate>
    
    参数
    
    other的其他时间相比，不空
    
    结果
    
    如果此日期时间为指定日期时间
  - isBefore
```
public boolean isBefore(ChronoLocalDateTime<?> other)
```
    检查此日期时间是否在指定日期时间之前。
    此检查查看此日期时间是否代表其他日期时间之前的本地时间行上的一个点。
```
localdate = localdatetime，（2012，6，30，12，00）；localdate B = localdatetime，（2012，7，1，12，00）；a.isbefore（B）= =真a.isbefore（一）= =假b.isbefore（一）= =假
```
    此方法只考虑在本地时间线上的两个日期时间的位置。它没有考虑到年代，或日历系统。这是不同于compareTo(ChronoLocalDateTime)比较，但跟ChronoLocalDateTime.timeLineOrder()相同。
    Specified by:
    
    isBefore 接口 ChronoLocalDateTime<LocalDate>
    
    参数
    
    other的其他时间相比，不空
    
    结果
    
    如果此日期时间为在指定日期时间之前
  - isEqual
```
public boolean isEqual(ChronoLocalDateTime<?> other)
```
    检查此日期时间是否等于指定的日期时间。
    此检查查看此日期时间是否代表本地时间线上的同一时间点，如其他日期时间。
```
localdate = localdatetime，（2012，6，30，12，00）；localdate B = localdatetime，（2012，7，1，12，00）；a.isequal（B）= =假a.isequal（一）= =真b.isequal（一）= =假
```
    此方法只考虑在本地时间线上的两个日期时间的位置。它没有考虑到年代，或日历系统。这是不同于compareTo(ChronoLocalDateTime)比较，但跟ChronoLocalDateTime.timeLineOrder()相同。
    Specified by:
    
    isEqual 接口 ChronoLocalDateTime<LocalDate>
    
    参数
    
    other的其他时间相比，不空
    
    结果
    
    如果此日期时间等于指定的日期时间，则为
  - equals
```
public boolean equals(Object obj)
```
    检查此日期时间是否等于另一个日期时间。
    这LocalDateTime与另一个确保日期时间是相同的比较。LocalDateTime型只有对象相比，其他类型返回false。
    
    Specified by:
    
    equals 接口 ChronoLocalDateTime<LocalDate>
    
    重写：
    
    equals 方法重写，继承类 Object
    
    参数
    
    obj -检查对象，空返回false
    
    结果
    
    如果这是等于另一日期时间
    
    另请参见：
    
    Object.hashCode()， HashMap
  - hashCode
```
public int hashCode()
```
    用于此日期时间的哈希代码。
    
    Specified by:
    
    hashCode 接口 ChronoLocalDateTime<LocalDate>
    
    重写：
    
    hashCode 方法重写，继承类 Object
    
    结果
    
    一个合适的哈希代码
    
    另请参见：
    
    Object.equals(java.lang.Object)， System.identityHashCode(java.lang.Object)
  - toString
```
public String toString()
```
    输出该日期时间为 String，如 2007-12-03T10:15:30。
    输出将下列ISO-8601格式：
    - uuuu-MM-dd'T'HH:mm
    - uuuu-MM-dd'T'HH:mm:ss
    - uuuu-MM-dd'T'HH:mm:ss.SSS
    - uuuu-MM-dd'T'HH:mm:ss.SSSSSS
    - uuuu-MM-dd'T'HH:mm:ss.SSSSSSSSS
    所用的格式将最短，输出的全部价值的时候，省略部分是暗示为零。
    Specified by:
    
    toString 接口 ChronoLocalDateTime<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 LocalDateTime

Field Summary

方法摘要

Methods inherited from class java.lang.Object

Methods inherited from interface java.time.chrono.ChronoLocalDateTime

Field Detail

MIN

MAX

方法详细信息

now

now

now

of

of

of

of

of

of

of

ofInstant

ofEpochSecond

from

parse

parse

isSupported

isSupported

range

get

getLong

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

atOffset

atZone

compareTo

isAfter