LocalDate (Java Platform SE 8 )

java.lang.Object
- java.time.LocalDate

All Implemented Interfaces:

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

这个类不存储或表示一个时间或时区。相反，它是一个描述的日期，为使用过的生日。它不能代表时间线上的即时，而不需要额外的信息，如偏移或时区。

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

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

实现要求：

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

从以下版本开始：

一点八

另请参见：

Serialized Form

Field Summary

Fields
Modifier and Type	Field and Description
`static LocalDate`	`MAX` 所支持的最大 `LocalDate`，' + 999999999 -12-31”。
`static LocalDate`	`MIN` 最小支持 `LocalDate`，”999999999 -01-01”。

方法摘要

所有方法静态方法接口方法具体的方法
Modifier and Type	Method and Description
`Temporal`	`adjustInto(Temporal temporal)` 调整指定的时间对象，以具有此对象的相同日期。
`LocalDateTime`	`atStartOfDay()` 结合这个日期与午夜的时间创建一个 `LocalDateTime`在这个日期开始。
`ZonedDateTime`	`atStartOfDay(ZoneId zone)` 根据时区的规则，在最早的有效时间内返回一个分区的时间。
`LocalDateTime`	`atTime(int hour, int minute)` 结合这个日期与时间创建一个 `LocalDateTime`。
`LocalDateTime`	`atTime(int hour, int minute, int second)` 结合这个日期与时间创建一个 `LocalDateTime`。
`LocalDateTime`	`atTime(int hour, int minute, int second, int nanoOfSecond)` 结合这个日期与时间创建一个 `LocalDateTime`。
`LocalDateTime`	`atTime(LocalTime time)` 结合这个日期与时间创建一个 `LocalDateTime`。
`OffsetDateTime`	`atTime(OffsetTime time)` 结合这个日期与时间偏移来创建一个 `OffsetDateTime`。
`int`	`compareTo(ChronoLocalDate other)` 将此日期与另一个日期进行比较。
`boolean`	`equals(Object obj)` 检查此日期是否等于另一个日期。
`String`	`format(DateTimeFormatter formatter)` 使用指定的格式的日期格式。
`static LocalDate`	`from(TemporalAccessor temporal)` 获得 `LocalDate`实例从一个时空对象。
`int`	`get(TemporalField field)` 获取指定字段的值，从这个日期作为一个 `int`。
`IsoChronology`	`getChronology()` 获取此日期的日期，这是国际标准化组织的日历系统。
`int`	`getDayOfMonth()` 获取月字段的一天。
`DayOfWeek`	`getDayOfWeek()` 获取星期域，这是一个枚举 `DayOfWeek`。
`int`	`getDayOfYear()` 获取一年的日子。
`Era`	`getEra()` 获取在这个日期适用的时代。
`long`	`getLong(TemporalField field)` 获取指定字段的值，从这个日期作为 `long`。
`Month`	`getMonth()` 得到月年田间使用 `Month`枚举。
`int`	`getMonthValue()` 从1到12得到一个月的时间字段。
`int`	`getYear()` 获取年度字段。
`int`	`hashCode()` 此日期的哈希代码。
`boolean`	`isAfter(ChronoLocalDate other)` 检查此日期是否在指定日期之后。
`boolean`	`isBefore(ChronoLocalDate other)` 检查此日期是否在指定日期之前。
`boolean`	`isEqual(ChronoLocalDate other)` 检查此日期是否等于指定日期。
`boolean`	`isLeapYear()` 检查，如果今年是闰年，根据ISO预期历法系统规则。
`boolean`	`isSupported(TemporalField field)` 检查指定字段是否被支持。
`boolean`	`isSupported(TemporalUnit unit)` 检查指定的单位是否被支持。
`int`	`lengthOfMonth()` 返回此日期所表示的月份的长度。
`int`	`lengthOfYear()` 返回此日期所表示的年份的长度。
`LocalDate`	`minus(long amountToSubtract, TemporalUnit unit)` 返回此日期的一个副本，用指定的金额减去。
`LocalDate`	`minus(TemporalAmount amountToSubtract)` 返回此日期的一个副本，用指定的金额减去。
`LocalDate`	`minusDays(long daysToSubtract)` 返回一份本 `LocalDate`与指定的天数减去。
`LocalDate`	`minusMonths(long monthsToSubtract)` 返回一份本 `LocalDate`与指定期个月减去。
`LocalDate`	`minusWeeks(long weeksToSubtract)` 返回一份本 `LocalDate`在周中减去指定的时间。
`LocalDate`	`minusYears(long yearsToSubtract)` 返回一份本 `LocalDate`与指定期在年中减去。
`static LocalDate`	`now()` 在默认时区中从系统时钟获取当前日期。
`static LocalDate`	`now(Clock clock)` 从指定的时钟获取当前日期。
`static LocalDate`	`now(ZoneId zone)` 从指定时区中的系统时钟中获取当前日期。
`static LocalDate`	`of(int year, int month, int dayOfMonth)` 获得 `LocalDate`实例从一年、月、日。
`static LocalDate`	`of(int year, Month month, int dayOfMonth)` 获得 `LocalDate`实例从一年、月、日。
`static LocalDate`	`ofEpochDay(long epochDay)` 获得 `LocalDate`实例从时代的日数。
`static LocalDate`	`ofYearDay(int year, int dayOfYear)` 获得 `LocalDate`实例从一年一年。
`static LocalDate`	`parse(CharSequence text)` 获得 `LocalDate`实例从一个文本字符串，如 `2007-12-03`。
`static LocalDate`	`parse(CharSequence text, DateTimeFormatter formatter)` 获得 `LocalDate`实例从使用特定格式的文本字符串。
`LocalDate`	`plus(long amountToAdd, TemporalUnit unit)` 返回此日期的一个副本，添加指定的金额。
`LocalDate`	`plus(TemporalAmount amountToAdd)` 返回此日期的一个副本，添加指定的金额。
`LocalDate`	`plusDays(long daysToAdd)` 返回一份本 `LocalDate`与指定的天数增加。
`LocalDate`	`plusMonths(long monthsToAdd)` 返回一份本 `LocalDate`在月期添加指定的。
`LocalDate`	`plusWeeks(long weeksToAdd)` 返回一份本 `LocalDate`在周指定期间补充。
`LocalDate`	`plusYears(long yearsToAdd)` 返回一份本 `LocalDate`年指定期间补充。
`<R> R`	`query(TemporalQuery<R> query)` 使用指定的查询查询此日期。
`ValueRange`	`range(TemporalField field)` 获取指定字段的有效值的范围。
`long`	`toEpochDay()` 将此日期转换为新纪元日。
`String`	`toString()` 输出该日期作为 `String`，如 `2007-12-03`。
`Period`	`until(ChronoLocalDate endDateExclusive)` 计算这个日期和日期之间的时间作为一个 `Period`。
`long`	`until(Temporal endExclusive, TemporalUnit unit)` 计算时间的量，直到指定单元的另一个日期为止。
`LocalDate`	`with(TemporalAdjuster adjuster)` 返回此日期的调整副本。
`LocalDate`	`with(TemporalField field, long newValue)` 将此日期的一个副本与指定的字段设置为一个新值。
`LocalDate`	`withDayOfMonth(int dayOfMonth)` 返回此日期的副本与月更改日期。
`LocalDate`	`withDayOfYear(int dayOfYear)` 返回此日期的副本与一年的日期更改。
`LocalDate`	`withMonth(int month)` 返回此日期的副本与更改的月份。
`LocalDate`	`withYear(int year)` 返回此日期的副本与年更改。

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

Methods inherited from interface java.time.chrono.ChronoLocalDate
timeLineOrder

- Field Detail
  - MIN
```
public static final LocalDate MIN
```
    最小支持 LocalDate，”999999999 -01-01”。这可以被一个应用程序作为一个“遥远的”日期。
  - MAX
```
public static final LocalDate MAX
```
    所支持的最大 LocalDate，' + 999999999 -12-31”。这可以被一个应用程序作为一个“遥远的未来”日期。
- 方法详细信息
  - now
```
public static LocalDate now()
```
    在默认时区中从系统时钟获取当前日期。
    这将查询system clock在默认时区获取当前日期。
    
    使用这种方法将防止使用另一个时钟进行测试的能力，因为时钟是硬编码的。
    
    结果
    
    使用系统时钟和默认时区的当前日期，而不是空的
  - now
```
public static LocalDate now(ZoneId zone)
```
    从指定时区中的系统时钟中获取当前日期。
    这将查询system clock获取当前日期。指定时区避免依赖于默认时区。
    
    使用这种方法将防止使用另一个时钟进行测试的能力，因为时钟是硬编码的。
    
    参数
    
    zone -区ID使用，不为空
    
    结果
    
    当前日期使用系统时钟，而不是空
  - now
```
public static LocalDate now(Clock clock)
```
    从指定的时钟获取当前日期。
    这将查询指定的时钟，以获得当前日期-今天。使用这种方法允许使用一个备用时钟进行测试。备用时钟可采用dependency injection。
    
    参数
    
    clock -时钟使用，不为空
    
    结果
    
    当前日期，而不是空
  - of
```
public static LocalDate of(int year,
                           Month month,
                           int dayOfMonth)
```
    获得 LocalDate实例从一年、月、日。
    这将返回一个与指定LocalDate年，月和日的月。一天必须是有效的，因为一年和一个月，否则将抛出异常。
    
    参数
    
    year年的代表，从min_year到max_year
    
    month -年月表示，不为空
    
    dayOfMonth -月代表天，从1到31
    
    结果
    
    本地日期，而不是空
    
    异常
    
    DateTimeException -如果任何字段的值超出范围，或如果月日年月日是无效的
  - of
```
public static LocalDate of(int year,
                           int month,
                           int dayOfMonth)
```
    获得 LocalDate实例从一年、月、日。
    这将返回一个与指定LocalDate年，月和日的月。一天必须是有效的，因为一年和一个月，否则将抛出异常。
    
    参数
    
    year年的代表，从min_year到max_year
    
    month -年月为代表，从1（一月）到12（十二月）
    
    dayOfMonth -月代表天，从1到31
    
    结果
    
    本地日期，而不是空
    
    异常
    
    DateTimeException -如果任何字段的值超出范围，或如果月日年月日是无效的
  - ofYearDay
```
public static LocalDate ofYearDay(int year,
                                  int dayOfYear)
```
    获得 LocalDate实例从一年一年。
    这将返回一个与指定的年日年LocalDate。一年的一天必须是有效的一年，否则将抛出一个异常。
    
    参数
    
    year年的代表，从min_year到max_year
    
    dayOfYear -年代表天，从1到366
    
    结果
    
    本地日期，而不是空
    
    异常
    
    DateTimeException -如果任何字段的值超出范围，或如果每年的这一天为年月日是无效的
  - ofEpochDay
```
public static LocalDate ofEpochDay(long epochDay)
```
    获得 LocalDate实例从时代的日数。
    返回具有指定期日LocalDate。是一个简单的EPOCH_DAY递增计数的日子，0天是1970-01-01。负数代表早期的日子。
    
    参数
    
    epochDay时代的天将，基于历元1970-01-01
    
    结果
    
    本地日期，而不是空
    
    异常
    
    DateTimeException如果时代天超过支持的日期范围
  - from
```
public static LocalDate from(TemporalAccessor temporal)
```
    获得 LocalDate实例从一个时空对象。
    这将根据指定的时间来获得一个本地日期。一个TemporalAccessor表示日期和时间信息，任意设置，本厂将以LocalDate实例。
    
    转换使用TemporalQueries.localDate()查询，这依赖于提取EPOCH_DAY场。
    
    这种方法相匹配的功能接口TemporalQuery可以通过方法引用查询的签名，LocalDate::from。
    
    Specified by:
    
    from 接口 ChronoLocalDate
    
    参数
    
    temporal -转换时间的对象，不为空
    
    结果
    
    本地日期，而不是空
    
    异常
    
    DateTimeException如果无法转换为 LocalDate
    
    另请参见：
    
    Chronology.date(TemporalAccessor)
  - parse
```
public static LocalDate parse(CharSequence text)
```
    获得 LocalDate实例从一个文本字符串，如 2007-12-03。
    该字符串必须是一个有效的日期和使用DateTimeFormatter.ISO_LOCAL_DATE解析。
    
    参数
    
    text -解析如“2007-12-03”文本，不空
    
    结果
    
    解析的本地日期，而不是空
    
    异常
    
    DateTimeParseException如果文本不能解析
  - parse
```
public static LocalDate parse(CharSequence text,
                              DateTimeFormatter formatter)
```
    获得 LocalDate实例从使用特定格式的文本字符串。
    文字使用格式化程序解析，返回一个日期。
    
    参数
    
    text -解析文本，不空
    
    formatter -格式化程序使用，不为空
    
    结果
    
    解析的本地日期，而不是空
    
    异常
    
    DateTimeParseException如果文本不能解析
  - isSupported
```
public boolean isSupported(TemporalField field)
```
    检查指定字段是否被支持。
    此检查如果此日期可以查询指定的字段。如果为false，则调用range，get和with(TemporalField, long)方法将抛出一个异常。
    
    如果该字段是ChronoField然后查询执行。支持的字段是：
    - 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 接口 ChronoLocalDate
    
    Specified by:
    
    isSupported 接口 TemporalAccessor
    
    参数
    
    field -现场检查null返回false
    
    结果
    
    如果此日期支持字段，则为假如果不是
  - isSupported
```
public boolean isSupported(TemporalUnit unit)
```
    检查指定的单位是否被支持。
    此检查如果指定的单位可以添加到或减去，这个日期时间。如果为false，则调用plus(long, TemporalUnit)和minus方法将抛出一个异常。
    
    如果单位是一个ChronoUnit然后查询执行。所支持的单位是：
    - DAYS
    - WEEKS
    - MONTHS
    - YEARS
    - DECADES
    - CENTURIES
    - MILLENNIA
    - ERAS
    所有其他 ChronoUnit实例将返回false。
    如果单位不ChronoUnit，然后通过调用作为参数传递this TemporalUnit.isSupportedBy(Temporal)得到此方法的结果。是否支持单位是由单位确定的。
    Specified by:
    
    isSupported 接口 ChronoLocalDate
    
    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将基于该数据的有效值，除了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如果数值溢出时
  - getChronology
```
public IsoChronology getChronology()
```
    获取此日期的日期，这是国际标准化组织的日历系统。
    的Chronology代表使用日历系统。该系统是现代民法ISO-8601日历日历系统中使用的大多数今天的世界。它相当于proleptic公历闰年的系统，在今天的规则适用于所有的时间。
    
    Specified by:
    
    getChronology 接口 ChronoLocalDate
    
    结果
    
    的国际标准组织的年代，而不是空
  - getEra
```
public Era getEra()
```
    获取在这个日期适用的时代。
    官方ISO-8601标准没有定义的时代，然而IsoChronology呢。它定义了两个时代，“CE”从第一年起，“年”从零年向后。由于之前Julian Gregorian cutover的日期是不符合历史，割接之间“公元前”和“CE”也不符合常用的时代，通常称为使用“公元前”和“广告”。
    
    这类用户通常会忽略这种方法因为它的存在主要是履行ChronoLocalDate合同需要支持日本的日历系统。
    
    返回的时代将是一个可利用的==算子在IsoChronology常数比单身。
    
    Specified by:
    
    getEra 接口 ChronoLocalDate
    
    结果
    
    在这不断的适用日期 IsoChronology时代，不为空
  - 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获得。这包括值的文本名称。
    枚举。
    
    结果
    
    星期的一天，不是空的
  - isLeapYear
```
public boolean isLeapYear()
```
    检查，如果今年是闰年，根据ISO预期历法系统规则。
    此方法适用于在整个时间线的当前规则的跨越式。一般来说，一年是闰年，如果它能被四整除而没有余数。然而，年100整除，不是闰年，以400的年分的例外。
    
    例如，1904是一个闰年是能被4整除。1900不是一个闰年为100是可分的，但是2000是一个闰年为400是可分的。
    
    计算预期的规则应用到遥远的未来和遥远的过去。这是不准确的，但正确的ISO-8601标准。
    
    Specified by:
    
    isLeapYear 接口 ChronoLocalDate
    
    结果
    
    如果一年是跳跃的，否则是错误的
  - lengthOfMonth
```
public int lengthOfMonth()
```
    返回此日期所表示的月份的长度。
    这将返回一个月的长度。例如，一月的一个日期将返回31。
    
    Specified by:
    
    lengthOfMonth 接口 ChronoLocalDate
    
    结果
    
    天月的长度
  - lengthOfYear
```
public int lengthOfYear()
```
    返回此日期所表示的年份的长度。
    这将返回一年的长度，无论是365或366。
    
    Specified by:
    
    lengthOfYear 接口 ChronoLocalDate
    
    结果
    
    366如果一年是跳跃，否则365
  - with
```
public LocalDate with(TemporalAdjuster adjuster)
```
    返回此日期的调整副本。
    这将返回一个LocalDate，基于这一日期的调整。调整使用指定的调整器策略对象。阅读调整器的文档，了解将要做什么调整。
    
    一个简单的调节器可以简单地设置一个字段，例如年字段。一个更复杂的调节器可能会把日期定在月的最后一天。选择常见的调整提供了TemporalAdjuster。这些措施包括寻找“月的最后一天”和“下星期三”。关键日期时间类也实现TemporalAdjuster接口，如Month和MonthDay。该调节器是负责处理特殊情况下，如不同长度的月和跳跃年。
    
    例如，此代码在七月的最后一天返回日期：
```
进口静态java。时间。月。*；进口静态java。时间。时间。调节。*；结果：localdate，（七月），（lastdayofmonth()）；
```
    这种方法的结果是通过调用指定的调节器，通过this作为论据的TemporalAdjuster.adjustInto(Temporal)方法得到的。
    
    此实例是不可变的，不受此方法调用的影响。
    Specified by:
    
    with 接口 ChronoLocalDate
    
    Specified by:
    
    with 接口 Temporal
    
    参数
    
    adjuster -调节器使用，不为空
    
    结果
    
    一个 LocalDate基于调整 this，不空
    
    异常
    
    DateTimeException -如果调整不能
    
    ArithmeticException如果数值溢出时
  - with
```
public LocalDate with(TemporalField field,
                      long newValue)
```
    将此日期的一个副本与指定的字段设置为一个新值。
    这将返回一个LocalDate，在此基础上，对指定字段的值的变化。这可以用来改变任何支持的领域，如一年，一个月或一天的月。如果不可能设置值，因为字段不支持或其他原因，则抛出异常。
    
    在某些情况下，改变指定的字段可以导致结果的日期无效，如更改从1月31日至二月的月将使月无效的日期。在这样的情况下，该字段是负责解决日期。通常情况下，它会选择以前的有效日期，这将是二月的最后一个有效的一天，在这个例子中。
    
    如果该字段是ChronoField然后调整在这里实现。所支持的字段如下：
    - DAY_OF_WEEK返回具有指定一周中的一天LocalDate。日期调整后的6天内向前或向后的边界内的一个星期一至星期日周。
    - ALIGNED_DAY_OF_WEEK_IN_MONTH -返回与指定的对齐星期LocalDate。日期调整到指定的月为基础的每周一天的时间。对齐的星期数，使得一个给定月份的第一个星期开始在那个月的第一天。这可能会导致日期被移动到6天到下个月。
    - ALIGNED_DAY_OF_WEEK_IN_YEAR -返回与指定的对齐星期LocalDate。日期调整到指定的一周的对齐日期的一周。对齐的星期数，使得一个给定的一年的第一个星期开始在那一年的第一天。这可能会导致日期被移动到6天到第二年。
    - DAY_OF_MONTH -返回与指定的日期LocalDate。一个月和一年将保持不变。如果月日年和月是无效的，那么DateTimeException抛出。
    - DAY_OF_YEAR返回具有指定年月日LocalDate。年将不变。如果每年的这一天的一年是无效的，那么DateTimeException抛出。
    - EPOCH_DAY返回具有指定期日LocalDate。这完全取代日期和相当于ofEpochDay(long)。
    - ALIGNED_WEEK_OF_MONTH返回具有指定对齐周月LocalDate。对齐的星期数，使得一个给定月份的第一个星期开始在那个月的第一天。这种调整将日期在整个一周的时间段内，以匹配指定的一周。结果将有同一天的一周，因为这个日期。这可能会导致日期被移动到下个月。
    - ALIGNED_WEEK_OF_YEAR返回具有指定对齐周年LocalDate。对齐的星期数，使得一个给定的一年的第一个星期开始在那一年的第一天。这种调整将日期在整个一周的时间段内，以匹配指定的一周。结果将有同一天的一周，因为这个日期。这可能会导致日期被移动到第二年。
    - MONTH_OF_YEAR返回具有指定月年LocalDate。年将不变。月日也将不变，除非它将是无效的新的一个月和一年。在这种情况下，一个月的一天调整为新的一个月和一年的最大有效值。
    - PROLEPTIC_MONTH返回具有指定预期月LocalDate。月日不变，除非新的一个月和一年将是无效的。在这种情况下，一个月的一天调整为新的一个月和一年的最大有效值。
    - YEAR_OF_ERA -返回与指定年份的时代LocalDate。这个时代和一个月将是不变的。月日也将不变，除非它将是无效的新的一个月和一年。在这种情况下，一个月的一天调整为新的一个月和一年的最大有效值。
    - YEAR -返回与指定的年LocalDate。本月将不变。月日也将不变，除非它将是无效的新的一个月和一年。在这种情况下，一个月的一天调整为新的一个月和一年的最大有效值。
    - ERA -返回与指定的时代LocalDate。时代和月将不变。月日也将不变，除非它将是无效的新的一个月和一年。在这种情况下，一个月的一天调整为新的一个月和一年的最大有效值。
    在所有的情况下，如果新的数值超出有效范围的领域，然后DateTimeException将抛出。
    
    所有其他ChronoField实例将抛出一个UnsupportedTemporalTypeException。
    
    如果该字段是不是ChronoField，然后通过调用作为参数传递this TemporalField.adjustInto(Temporal, long)得到此方法的结果。在这种情况下，字段决定是否以及如何调整即时。
    
    此实例是不可变的，不受此方法调用的影响。
    Specified by:
    
    with 接口 ChronoLocalDate
    
    Specified by:
    
    with 接口 Temporal
    
    参数
    
    field -现场设置的结果，不为空
    
    newValue -场的结果中的新价值
    
    结果
    
    一个 LocalDate基于指定的字段集 this，不空
    
    异常
    
    DateTimeException -如果该字段不能设置
    
    UnsupportedTemporalTypeException如果字段不支持
    
    ArithmeticException如果数值溢出时
  - withYear
```
public LocalDate withYear(int year)
```
    返回此日期的副本与年更改。如果一个月的一天是无效的，它将被更改为月的最后一个有效的一天。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    year年设置的结果，从min_year到max_year
    
    结果
    
    与请求的一年这一天 LocalDate为主，不为空
    
    异常
    
    DateTimeException如果年值无效
  - withMonth
```
public LocalDate withMonth(int month)
```
    返回此日期的副本与更改的月份。如果一个月的一天是无效的，它将被更改为月的最后一个有效的一天。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    month -年月在结果集，从1（一月）到12（十二月）
    
    结果
    
    与请求的月这一天 LocalDate为主，不为空
    
    异常
    
    DateTimeException如果年值月是无效的
  - withDayOfMonth
```
public LocalDate withDayOfMonth(int dayOfMonth)
```
    返回此日期的副本与月更改日期。如果生成的日期无效，则抛出一个异常。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    dayOfMonth -月在结果集的一天，从1至28
    
    结果
    
    与请求日这一天 LocalDate为主，不为空
    
    异常
    
    DateTimeException如果月值一天是无效的，或者如果月日年月日是无效的
  - withDayOfYear
```
public LocalDate withDayOfYear(int dayOfYear)
```
    返回此日期的副本与一年的日期更改。如果生成的日期无效，则抛出一个异常。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    dayOfYear -一年建立在结果的那一天，从1到杂志
    
    结果
    
    与请求日这一天 LocalDate为主，不为空
    
    异常
    
    DateTimeException如果年值一天是无效的，或者如果一天今年是无效的
  - plus
```
public LocalDate plus(TemporalAmount amountToAdd)
```
    返回此日期的一个副本，添加指定的金额。
    这将返回一个LocalDate，在此基础上，用指定的添加量。量通常是Period但可能是任何其他类型的TemporalAmount接口实现。
    
    计算委托量对象通过调用TemporalAmount.addTo(Temporal)数量，实现免费在任何情况下它的愿望实现，但是它通常称为回plus(long, TemporalUnit)。咨询量的执行文件以确定它是否可以成功添加。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    plus 接口 ChronoLocalDate
    
    Specified by:
    
    plus 接口 Temporal
    
    参数
    
    amountToAdd -添加量，不为空
    
    结果
    
    加上这一天 LocalDate为主，不为空
    
    异常
    
    DateTimeException如果还不能
    
    ArithmeticException如果数值溢出时
  - plus
```
public LocalDate plus(long amountToAdd,
                      TemporalUnit unit)
```
    返回此日期的一个副本，添加指定的金额。
    这将返回一个LocalDate，基于此，在单元的添加量。如果它是不可能添加的量，因为该单元不支持或其他原因，则抛出异常。
    
    在某些情况下，添加量可以导致结果的日期无效。例如，添加一个月到1月31日将导致在2月31日。在这样的情况下，该单位负责解决日期。通常情况下，它会选择以前的有效日期，这将是二月的最后一个有效的一天，在这个例子中。
    
    如果该字段是ChronoUnit然后添加在这里实现。所支持的字段如下：
    - DAYS -返回与指定的天数LocalDate添加。这相当于plusDays(long)。
    - WEEKS返回具有指定的周数增加LocalDate。这相当于plusWeeks(long)和使用一个星期7天。
    - MONTHS -返回一个与指定数个月LocalDate添加。这相当于plusMonths(long)。月日不变，除非新的一个月和一年将是无效的。在这种情况下，一个月的一天调整为新的一个月和一年的最大有效值。
    - YEARS -返回一个与指定数年LocalDate添加。这相当于plusYears(long)。月日除非将无效的新的月和年是不变的。在这种情况下，一个月的一天调整为新的一个月和一年的最大有效值。
    - DECADES -返回一个与指定数年LocalDate添加。这相当于用金额乘以10呼叫plusYears(long)。月日不变，除非新的一个月和一年将是无效的。在这种情况下，一个月的一天调整为新的一个月和一年的最大有效值。
    - CENTURIES -返回与指定数世纪LocalDate添加。这相当于用金额乘以100呼叫plusYears(long)。月日不变，除非新的一个月和一年将是无效的。在这种情况下，一个月的一天调整为新的一个月和一年的最大有效值。
    - MILLENNIA返回具有指定数量的千年LocalDate添加。这相当于用金额乘以1000呼叫plusYears(long)。月日不变，除非新的一个月和一年将是无效的。在这种情况下，一个月的一天调整为新的一个月和一年的最大有效值。
    - ERAS返回具有指定数量的时代LocalDate添加。只有两个时代是支持的，所以金额必须是一个，零或负一个。如果金额为非零，则年是改变的，这样的时代是不变的。月日不变，除非新的一个月和一年将是无效的。在这种情况下，一个月的一天调整为新的一个月和一年的最大有效值。
    所有其他ChronoUnit实例将抛出一个UnsupportedTemporalTypeException。
    
    如果该字段是不是ChronoUnit，然后通过调用作为参数传递this TemporalUnit.addTo(Temporal, long)得到此方法的结果。在这种情况下，该单元确定是否和如何执行加法。
    
    此实例是不可变的，不受此方法调用的影响。
    Specified by:
    
    plus 接口 ChronoLocalDate
    
    Specified by:
    
    plus 接口 Temporal
    
    参数
    
    amountToAdd -单位的数量增加的结果，可能是负面的
    
    unit -量的单位添加，不为空
    
    结果
    
    用指定的添加量在这个日期 LocalDate为主，不为空
    
    异常
    
    DateTimeException如果还不能
    
    UnsupportedTemporalTypeException如果单位不支持
    
    ArithmeticException如果数值溢出时
  - plusYears
```
public LocalDate plusYears(long yearsToAdd)
```
    返回一份本 LocalDate年指定期间补充。
    此方法将指定的金额添加到三个步骤中的年字段中：
    1. 添加输入年到年字段
    2. 检查结果日期是否无效
    3. 调整一个月的一天，如果必要的话，最后一个有效的一天
    例如，2008-02-29（闰年）加一年会导致无效的日期2009-02-29（标准年）。而不是返回一个无效的结果，最后一日的一个月，2009-02-28所代替。
    
    此实例是不可变的，不受此方法调用的影响。
    参数
    
    yearsToAdd -加年，可能是负面的
    
    结果
    
    同年加入这一天 LocalDate为主，不为空
    
    异常
    
    DateTimeException -如果结果超过支持的日期范围
  - plusMonths
```
public LocalDate plusMonths(long monthsToAdd)
```
    返回一份本 LocalDate在月期添加指定的。
    此方法在三个步骤中添加指定的金额到月字段中：
    1. 添加输入月到年字段
    2. 检查结果日期是否无效
    3. 调整一个月的一天，如果必要的话，最后一个有效的一天
    例如，2007-03-31加一个月会导致无效的日期2007-04-31。而不是返回一个无效的结果，最后一日的一个月，2007-04-30所代替。
    
    此实例是不可变的，不受此方法调用的影响。
    参数
    
    monthsToAdd -加个月，可能是负面的
    
    结果
    
    基于这一 LocalDate日与月说，不空
    
    异常
    
    DateTimeException -如果结果超过支持的日期范围
  - plusWeeks
```
public LocalDate plusWeeks(long weeksToAdd)
```
    返回一份本 LocalDate在周指定期间补充。
    此方法将指定数量的天场周递增的月和年等要保证结果仍然有效。如果超出最大/最小年，则结果是无效的。
    
    例如，2008-12-31加一周会导致2009-01-07。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    weeksToAdd -加周，可能是负面的
    
    结果
    
    一个 LocalDate基于日期与星期补充道，不空
    
    异常
    
    DateTimeException -如果结果超过支持的日期范围
  - plusDays
```
public LocalDate plusDays(long daysToAdd)
```
    返回一份本 LocalDate与指定的天数增加。
    该方法将指定数量的天场递增的年和月的领域要保证结果仍然有效。如果超出最大/最小年，则结果是无效的。
    
    例如，2008-12-31加一天会导致一。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    daysToAdd -添加的日子，可能是负面的
    
    结果
    
    有天说这一天 LocalDate为主，不为空
    
    异常
    
    DateTimeException -如果结果超过支持的日期范围
  - minus
```
public LocalDate minus(TemporalAmount amountToSubtract)
```
    返回此日期的一个副本，用指定的金额减去。
    这将返回一个LocalDate，在此基础上，用指定的金额减去。量通常是Period但可能是任何其他类型的TemporalAmount接口实现。
    
    计算委托量对象通过调用TemporalAmount.subtractFrom(Temporal)数量，实现自由以任何方式希望实现减法，但它通常需要回minus(long, TemporalUnit)。咨询文档的量的实现，以确定它是否可以成功地减去。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    minus 接口 ChronoLocalDate
    
    Specified by:
    
    minus 接口 Temporal
    
    参数
    
    amountToSubtract -减去的量，不为空
    
    结果
    
    用减法，让这一天 LocalDate为主，不为空
    
    异常
    
    DateTimeException如果减法不能做
    
    ArithmeticException如果数值溢出时
  - minus
```
public LocalDate minus(long amountToSubtract,
                       TemporalUnit unit)
```
    返回此日期的一个副本，用指定的金额减去。
    这将返回一个LocalDate，在此基础上，对单位金额减去。如果它是不可能的减去的量，因为该单位不支持或一些其他原因，一个异常被抛出。
    
    这种方法相当于plus(long, TemporalUnit)量与否定。见该方法充分说明了如何加法，从而减法，作品。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    minus 接口 ChronoLocalDate
    
    Specified by:
    
    minus 接口 Temporal
    
    参数
    
    amountToSubtract -减去从结果数额的单位，可能是负面的
    
    unit -金额单位减，不为空
    
    结果
    
    用指定的金额减去这一天 LocalDate为主，不为空
    
    异常
    
    DateTimeException如果减法不能做
    
    UnsupportedTemporalTypeException如果单位不支持
    
    ArithmeticException如果数值溢出时
  - minusYears
```
public LocalDate minusYears(long yearsToSubtract)
```
    返回一份本 LocalDate与指定期在年中减去。
    该方法中减去指定的金额从三步来场：
    1. 减去输入年到年字段
    2. 检查结果日期是否无效
    3. 调整一个月的一天，如果必要的话，最后一个有效的一天
    例如，2008-02-29（闰年）减去一年会导致无效的日期2007-02-29（标准年）。而不是返回一个无效的结果，最后一日的一个月，2007-02-28所代替。
    
    此实例是不可变的，不受此方法调用的影响。
    参数
    
    yearsToSubtract -减去年，可能是负面的
    
    结果
    
    随着年中减去这一天 LocalDate为主，不为空
    
    异常
    
    DateTimeException -如果结果超过支持的日期范围
  - minusMonths
```
public LocalDate minusMonths(long monthsToSubtract)
```
    返回一份本 LocalDate与指定期个月减去。
    该方法中减去指定的金额从三步月场：
    1. 减去输入月到一个月的时间字段
    2. 检查结果日期是否无效
    3. 调整一个月的一天，如果必要的话，最后一个有效的一天
    例如，2007-03-31减去一个月会导致无效的日期2007-02-31。而不是返回一个无效的结果，最后一日的一个月，2007-02-28所代替。
    
    此实例是不可变的，不受此方法调用的影响。
    参数
    
    monthsToSubtract -减去个月，可能是负面的
    
    结果
    
    与月减去这一天 LocalDate为主，不为空
    
    异常
    
    DateTimeException -如果结果超过支持的日期范围
  - minusWeeks
```
public LocalDate minusWeeks(long weeksToSubtract)
```
    返回一份本 LocalDate在周中减去指定的时间。
    该方法在周中减去指定的金额从天场递减的年份和月份等要保证结果仍然有效。如果超出最大/最小年，则结果是无效的。
    
    例如，2009-01-07减去一周会导致2008-12-31。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    weeksToSubtract -减去的数周，可能是负面的
    
    结果
    
    与周中减去这一天 LocalDate为主，不为空
    
    异常
    
    DateTimeException -如果结果超过支持的日期范围
  - minusDays
```
public LocalDate minusDays(long daysToSubtract)
```
    返回一份本 LocalDate与指定的天数减去。
    该方法中减去指定的金额从天场递减的年份和月份等要保证结果仍然有效。如果超出最大/最小年，则结果是无效的。
    
    例如，一减一天会导致2008-12-31。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    daysToSubtract -减去几天，可能是负面的
    
    结果
    
    与天减去这一天 LocalDate为主，不为空
    
    异常
    
    DateTimeException -如果结果超过支持的日期范围
  - query
```
public <R> R query(TemporalQuery<R> query)
```
    使用指定的查询查询此日期。
    此查询使用指定的查询策略对象查询此日期。的TemporalQuery对象定义了用来获得结果的逻辑。阅读查询的文档，了解该方法的结果将是什么。
    
    这种方法的结果是通过调用指定的查询通过this作为论据的TemporalQuery.queryFrom(TemporalAccessor)方法得到的。
    
    Specified by:
    
    query 接口 ChronoLocalDate
    
    Specified by:
    
    query 接口 TemporalAccessor
    
    参数类型
    
    R -结果的类型
    
    参数
    
    query -调用查询，不空
    
    结果
    
    查询结果，可以返回（由查询所定义）
    
    异常
    
    DateTimeException如果无法查询（查询所定义）
    
    ArithmeticException如果数值溢出时（由查询定义）
  - adjustInto
```
public Temporal adjustInto(Temporal temporal)
```
    调整指定的时间对象，以具有此对象的相同日期。
    这将返回一个相同可观察类型的时间对象，因为输入的日期更改为与此相同的。
    
    调整是相当于用Temporal.with(TemporalField, long)传递ChronoField.EPOCH_DAY作为现场。
    
    在大多数情况下，更清晰的用Temporal.with(TemporalAdjuster)反向调用模式：
```
这两条线是等价的，但第二种方法是建议时间= thislocaldate adjustinto（时间）；时间=（thislocaldate）与时间；
```
    此实例是不可变的，不受此方法调用的影响。
    Specified by:
    
    adjustInto 接口 ChronoLocalDate
    
    Specified by:
    
    adjustInto 接口 TemporalAdjuster
    
    参数
    
    temporal -调整目标对象，不为空
    
    结果
    
    调整后的对象，而不是空
    
    异常
    
    DateTimeException如果无法适应
    
    ArithmeticException如果数值溢出时
  - until
```
public long until(Temporal endExclusive,
                  TemporalUnit unit)
```
    计算时间的量，直到指定单元的另一个日期为止。
    这两LocalDate计算对象之间的时间量在一个TemporalUnit条款。开始和结束点this和指定的日期。结果将是负的，如果结束之前开始。的Temporal传递给此方法转换为LocalDate使用from(TemporalAccessor)。例如，两个日期之间的天数的量可以计算出使用startDate.until(endDate, DAYS)。
    
    计算返回一个整数，表示两个日期之间的完整单位数。例如，2012-06-15和2012-08-14之间月量将只有一个月，因为它是短暂的两个月的一天。
    
    使用这种方法有两个等效的方法。首先是调用这个方法。二是用TemporalUnit.between(Temporal, Temporal)：
```
这两条线是等价的金额=开始，直到（结束，月）；金额=月间（开始，结束）；
```
    的选择应基于使得代码更易读。
    计算中实现该方法ChronoUnit。单位DAYS，WEEKS，MONTHS，YEARS，DECADES，CENTURIES，MILLENNIA和ERAS支持。其他ChronoUnit值将抛出一个异常。
    
    如果单位不ChronoUnit，然后通过调用TemporalUnit.between(Temporal, Temporal) this作为第一个参数传递和转换的输入时间作为第二个参数给出了这个方法的结果。
    
    此实例是不可变的，不受此方法调用的影响。
    Specified by:
    
    until 接口 ChronoLocalDate
    
    Specified by:
    
    until 接口 Temporal
    
    参数
    
    endExclusive -结束日期，排斥，这是转化为一个 LocalDate，不空
    
    unit -单位量来衡量，不为空
    
    结果
    
    这个日期和结束日期之间的时间
    
    异常
    
    DateTimeException如果金额无法计算，或结束时间不能转换为 LocalDate
    
    UnsupportedTemporalTypeException如果单位不支持
    
    ArithmeticException如果数值溢出时
  - until
```
public Period until(ChronoLocalDate endDateExclusive)
```
    计算这个日期和日期之间的时间作为一个 Period。
    这计算了两个日期之间的期限，几年，几个月和几天。开始和结束点this和指定的日期。结果将是负的，如果结束之前开始。在每一年，一个月和一天，消极的标志会是一样的。
    
    使用的是的的的日历系统进行计算。如果必要的话，输入日期将被转换为。
    
    开始日期包括在内，但结束日期不是。该期间计算通过删除完整的几个月，然后计算剩余天数，调整，以确保都有相同的标志。数月，然后归为数年和月的基础上12个月的一年。一个月被认为是完整的，如果一个月的结束日期大于或等于月的开始日。例如，从2010-01-15到2011-03-18是1年，2个月3天”。
    
    使用这种方法有两个等效的方法。首先是调用这个方法。二是用Period.between(LocalDate, LocalDate)：
```
这两条线是等价的期间=开始，直到（结束）；期间=期间（开始，结束）；
```
    的选择应基于使得代码更易读。
    Specified by:
    
    until 接口 ChronoLocalDate
    
    参数
    
    endDateExclusive -结束日期，独家的，这可能是在任何年代，不空
    
    结果
    
    这个日期和结束日期之间的期间，而不是空
  - format
```
public String format(DateTimeFormatter formatter)
```
    使用指定的格式的日期格式。
    该日期将被传递到格式化程序产生一个字符串。
    
    Specified by:
    
    format 接口 ChronoLocalDate
    
    参数
    
    formatter -格式化程序使用，不为空
    
    结果
    
    格式化的日期字符串，而不是空的
    
    异常
    
    DateTimeException如果打印时发生错误
  - atTime
```
public LocalDateTime atTime(LocalTime time)
```
    结合这个日期与时间创建一个 LocalDateTime。
    这会返回一个由这个日期在指定的时间LocalDateTime。日期和时间的所有可能的组合都是有效的。
    
    Specified by:
    
    atTime 接口 ChronoLocalDate
    
    参数
    
    time -时间结合，不为空
    
    结果
    
    从这个日期和指定时间形成的本地日期时间，而不是空
  - atTime
```
public LocalDateTime atTime(int hour,
                            int minute)
```
    结合这个日期与时间创建一个 LocalDateTime。
    这会返回一个由这个日期在指定的小时和分钟LocalDateTime。秒和纳秒级的字段将被设置为零。各个时间字段必须在其有效范围内。日期和时间的所有可能的组合都是有效的。
    
    参数
    
    hour -天使用时间，从0到23
    
    minute -小时使用时间，从0到59
    
    结果
    
    从这个日期和指定时间形成的本地日期时间，而不是空
    
    异常
    
    DateTimeException -如果任何字段的值超出范围
  - atTime
```
public LocalDateTime atTime(int hour,
                            int minute,
                            int second)
```
    结合这个日期与时间创建一个 LocalDateTime。
    这会返回一个由这个日期在指定LocalDateTime小时，分钟和第二。纳秒级场将被设置为零。各个时间字段必须在其有效范围内。日期和时间的所有可能的组合都是有效的。
    
    参数
    
    hour -天使用时间，从0到23
    
    minute -小时使用时间，从0到59
    
    second -二分为代表，从0到59
    
    结果
    
    从这个日期和指定时间形成的本地日期时间，而不是空
    
    异常
    
    DateTimeException -如果任何字段的值超出范围
  - atTime
```
public LocalDateTime atTime(int hour,
                            int minute,
                            int second,
                            int nanoOfSecond)
```
    结合这个日期与时间创建一个 LocalDateTime。
    这会返回一个由这个日期在指定的小时，分钟LocalDateTime，二和纳秒。各个时间字段必须在其有效范围内。日期和时间的所有可能的组合都是有效的。
    
    参数
    
    hour -天使用时间，从0到23
    
    minute -小时使用时间，从0到59
    
    second -二分为代表，从0到59
    
    nanoOfSecond -二代表纳米，从0到999999999
    
    结果
    
    从这个日期和指定时间形成的本地日期时间，而不是空
    
    异常
    
    DateTimeException -如果任何字段的值超出范围
  - atTime
```
public OffsetDateTime atTime(OffsetTime time)
```
    结合这个日期与时间偏移来创建一个 OffsetDateTime。
    返回由该日期在指定的时间OffsetDateTime。日期和时间的所有可能的组合都是有效的。
    
    参数
    
    time -时间结合，不为空
    
    结果
    
    从这个日期和指定时间形成的偏移日期时间，而不是空值
  - atStartOfDay
```
public LocalDateTime atStartOfDay()
```
    结合本期与午夜的时间在这个日期开始创建一个 LocalDateTime。
    这将返回一个LocalDateTime由这日午夜，时间00:00，在这一天的开始。
    
    结果
    
    这个日期开始时的午夜的本地日期时间，不是空的
  - atStartOfDay
```
public ZonedDateTime atStartOfDay(ZoneId zone)
```
    根据时区的规则，在最早的有效时间内返回一个分区的时间。
    时区规则，如日光节约，这意味着不是每个本地日期时间对指定区域是有效的，因此本地日期时间可能不在午夜。
    
    在大多数情况下，只有一个本地日期时间的有效偏移量。在重叠的情况下，有两个有效的偏移量，和较早的一个是使用，对应于第一次发生的午夜日期。在一个缺口的情况下，划时代的时间将代表即时只是在差距。
    
    如果带身份证是一个ZoneOffset，结果总是有一个时间的午夜。
    
    将在一个特定的时区叫atTime(LocalTime)随后LocalDateTime.atZone(ZoneId)具体时间。
    
    参数
    
    zone -区ID使用，不为空
    
    结果
    
    从这个日期形成的区域日期时间和区域的最早有效时间，而不是空的
  - toEpochDay
```
public long toEpochDay()
```
    从接口复制的描述： ChronoLocalDate
    
    将此日期转换为新纪元日。
    是一个简单的Epoch Day count递增计数的日子，0天是1970-01-01（ISO）。这个定义是所有年表一样，使转换。
    
    此默认实现查询EPOCH_DAY场。
    
    Specified by:
    
    toEpochDay 接口 ChronoLocalDate
    
    结果
    
    这个日期的时代相当于这个日期
  - compareTo
```
public int compareTo(ChronoLocalDate other)
```
    将此日期与另一个日期进行比较。
    比较主要是基于日期，从最早到最新的。这是“等于”一致，所定义的Comparable。
    
    如果所有被比较的日期LocalDate实例比较，然后将完全基于日期。如果一些日期比较在不同的年表，那么时间也被认为是，看到ChronoLocalDate.compareTo(java.time.chrono.ChronoLocalDate)。
    
    Specified by:
    
    compareTo 接口 Comparable<ChronoLocalDate>
    
    Specified by:
    
    compareTo 接口 ChronoLocalDate
    
    参数
    
    other -其他日期进行比较，不为空
    
    结果
    
    比较器的值，负的，如果少，积极的，如果更大
  - isAfter
```
public boolean isAfter(ChronoLocalDate other)
```
    检查此日期是否在指定日期之后。
    此检查，看看这个日期是否代表了另一个日期后的本地时间线上的一个点。
```
localdate = localdate，（2012，6，30）；localdate B = localdate，（2012，7，1）；a.isafter（B）= =假a.isafter（一）= =假b.isafter（一）= =真
```
    此方法只考虑两个日期在本地时间线上的位置。它没有考虑到年代，或日历系统。这是不同于compareTo(ChronoLocalDate)比较，但跟ChronoLocalDate.timeLineOrder()相同。
    Specified by:
    
    isAfter 接口 ChronoLocalDate
    
    参数
    
    other -其他日期进行比较，不为空
    
    结果
    
    如果这个日期是在指定日期之后
  - isBefore
```
public boolean isBefore(ChronoLocalDate other)
```
    检查此日期是否在指定日期之前。
    此检查，看看这个日期是否代表了另一个日期前的本地时间线上的一个点。
```
localdate = localdate，（2012，6，30）；localdate B = localdate，（2012，7，1）；a.isbefore（B）= =真a.isbefore（一）= =假b.isbefore（一）= =假
```
    此方法只考虑两个日期在本地时间线上的位置。它没有考虑到年代，或日历系统。这是不同于compareTo(ChronoLocalDate)比较，但跟ChronoLocalDate.timeLineOrder()相同。
    Specified by:
    
    isBefore 接口 ChronoLocalDate
    
    参数
    
    other -其他日期进行比较，不为空
    
    结果
    
    如果此日期在指定日期前为真
  - isEqual
```
public boolean isEqual(ChronoLocalDate other)
```
    检查此日期是否等于指定日期。
    此检查查看此日期是否代表本地时间线上的同一时间点的其他日期。
```
localdate = localdate，（2012，6，30）；localdate B = localdate，（2012，7，1）；a.isequal（B）= =假a.isequal（一）= =真b.isequal（一）= =假
```
    此方法只考虑两个日期在本地时间线上的位置。它没有考虑到年代，或日历系统。这是不同于compareTo(ChronoLocalDate)比较但方法ChronoLocalDate.timeLineOrder()相同。
    Specified by:
    
    isEqual 接口 ChronoLocalDate
    
    参数
    
    other -其他日期进行比较，不为空
    
    结果
    
    如果此日期等于指定日期，则为
  - equals
```
public boolean equals(Object obj)
```
    检查此日期是否等于另一个日期。
    这LocalDate与另一个确保日期是相同的比较。
    
    LocalDate型只有对象相比，其他类型返回false。比较两TemporalAccessor实例的日期，包括在两个不同的年表的日期，使用ChronoField.EPOCH_DAY作为比较器。
    
    Specified by:
    
    equals 接口 ChronoLocalDate
    
    重写：
    
    equals 方法重写，继承类 Object
    
    参数
    
    obj -检查对象，空返回false
    
    结果
    
    如果这是等于另一日期
    
    另请参见：
    
    Object.hashCode()， HashMap
  - hashCode
```
public int hashCode()
```
    此日期的哈希代码。
    
    Specified by:
    
    hashCode 接口 ChronoLocalDate
    
    重写：
    
    hashCode 方法重写，继承类 Object
    
    结果
    
    一个合适的哈希代码
    
    另请参见：
    
    Object.equals(java.lang.Object)， System.identityHashCode(java.lang.Object)
  - toString
```
public String toString()
```
    输出该日期作为 String，如 2007-12-03。
    输出将在uuuu-MM-dd ISO-8601格式。
    
    Specified by:
    
    toString 接口 ChronoLocalDate
    
    重写：
    
    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 LocalDate

Field Summary

方法摘要

Methods inherited from class java.lang.Object

Methods inherited from interface java.time.chrono.ChronoLocalDate

Field Detail

MIN

MAX

方法详细信息

now

now

now

of

of

ofYearDay

ofEpochDay

from

parse

parse

isSupported

isSupported

range

get

getLong

getChronology

getEra

getYear

getMonthValue

getMonth

getDayOfMonth

getDayOfYear

getDayOfWeek

isLeapYear

lengthOfMonth

lengthOfYear

with

with

withYear

withMonth

withDayOfMonth

withDayOfYear

plus

plus

plusYears

plusMonths

plusWeeks

plusDays

minus

minus

minusYears

minusMonths

minusWeeks

minusDays

query

adjustInto

until

until

format

atTime

atTime

atTime

atTime

atTime

atStartOfDay

atStartOfDay

toEpochDay

compareTo

isAfter

isBefore

isEqual

equals

hashCode

toString