All Implemented Interfaces:

Serializable ， Comparable<ChronoLocalDate> ， ChronoLocalDate ， Temporal ， TemporalAccessor ， TemporalAdjuster
```
public final class LocalDate
extends Object
implements Temporal, TemporalAdjuster, ChronoLocalDate, Serializable
```
在ISO- 2007-12-03 ，如2007-12-03 。
LocalDate是一个不可变的日期时间对象，表示日期，通常被视为年月日。也可以访问其他日期字段，例如日期，星期几和星期。例如，值“2007年10月2日”可以存储在LocalDate 。

该类不存储或表示时间或时区。相反，它是日期的描述，用于生日。它不能表示时间线上的瞬时，没有附加信息，如偏移或时区。

ISO-8601日历系统是当今世界绝大多数的现代民用日历系统。它相当于今天的闰年规则一直适用于日常生活的公历日历系统。对于今天写的大多数应用，ISO-8601规则是完全合适的。然而，任何利用历史日期并要求它们准确的应用程序都将发现ISO-8601方法不合适。

这是一个value-based类; 对LocalDate实例使用身份敏感操作（包括引用等式（ == ），身份哈希码或同步）可能会产生不可预知的结果，应该避免。 equals方法应用于比较。

实现要求：

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

从以下版本开始：

1.8

另请参见：

Serialized Form

Field Summary

Fields
Modifier and Type	Field	描述
`static LocalDate`	`EPOCH`	时代年份 `LocalDate` ，'1970-01-01'。
`static LocalDate`	`MAX`	最大支持 `LocalDate` ，'+ 999999999-12-31'。
`static LocalDate`	`MIN`	最低支持 `LocalDate` ，'- `LocalDate` '。

方法摘要

所有方法静态方法接口方法具体的方法
Modifier and Type	方法	描述
`Temporal`	`adjustInto(Temporal temporal)`	调整指定的时间对象与此对象的日期相同。
`LocalDateTime`	`atStartOfDay()`	将此日期与午夜时间结合 `LocalDateTime` ，在此日期开始时创建一个 `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)`	将此日期与另一个日期进行比较。
`Stream<LocalDate>`	`datesUntil(LocalDate endExclusive)`	返回顺序排列的日期流。
`Stream<LocalDate>`	`datesUntil(LocalDate endExclusive, Period step)`	通过给定的增量步骤返回日期的顺序排序流。
`boolean`	`equals(Object obj)`	检查这个日期是否等于另一个日期。
`String`	`format(DateTimeFormatter formatter)`	使用指定的格式化程序格式化此日期。
`static LocalDate`	`from(TemporalAccessor temporal)`	从时间对象获取一个 `LocalDate`的实例。
`int`	`get(TemporalField field)`	从此日期获取指定字段的值作为 `int` 。
`IsoChronology`	`getChronology()`	获取这个日期的时间顺序，即ISO日历系统。
`int`	`getDayOfMonth()`	获取月份字段。
`DayOfWeek`	`getDayOfWeek()`	获取星期几字段，这是一个枚举 `DayOfWeek` 。
`int`	`getDayOfYear()`	获得日期字段。
`IsoEra`	`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`指定的周数。
`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`	`ofInstant(Instant instant, ZoneId zone)`	从 `Instant`和区域ID获取 `LocalDate`的实例。
`static LocalDate`	`ofYearDay(int year, int dayOfYear)`	从一年和一年的一年中获得 `LocalDate`的实例。
`static LocalDate`	`parse(CharSequence text)`	从 `2007-12-03`等文本字符串获取 `LocalDate`的实例。
`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()`	将此日期转换为大纪元日。
`long`	`toEpochSecond(LocalTime time, ZoneOffset offset)`	将此 `LocalDate`转换为从1970-01-01T00：00：00Z开始的秒数。
`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`的副本，并更改日期。
`LocalDate`	`withDayOfYear(int dayOfYear)`	返回此 `LocalDate`更改的 `LocalDate`的副本。
`LocalDate`	`withMonth(int month)`	返回这个 `LocalDate`的副本，并更改月份。
`LocalDate`	`withYear(int year)`	返回该 `LocalDate`的副本。

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

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

- 字段详细信息
  - MIN
```
public static final LocalDate MIN
```
    最低支持LocalDate '。应用程序可以将其用作“过去”的日期。
  - MAX
```
public static final LocalDate MAX
```
    最大支持LocalDate ，'+ 999999999-12-31'。应用程序可以将其用作“远未来”的日期。
  - EPOCH
```
public static final LocalDate EPOCH
```
    时代年份 LocalDate ，'1970-01-01'。
- 方法详细信息
  - 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 - 要使用的时钟，不为空
    
    结果
    
    当前日期，不为null
  - of
```
public static LocalDate of(int year,
                           Month month,
                           int dayOfMonth)
```
    从一年，一个月和一天获得LocalDate的实例。
    这将返回一个LocalDate与指定的年，月和日。该日期必须在年和月中有效，否则将抛出异常。
    
    参数
    
    year - 从MIN_YEAR到MAX_YEAR的年份
    
    month - 代表的月份，不为null
    
    dayOfMonth - 代表从1到31的月份
    
    结果
    
    本地日期，不为空
    
    异常
    
    DateTimeException - 如果任何字段的值超出范围，或者月的日期对于月份无效
  - of
```
public static LocalDate of(int year,
                           int month,
                           int dayOfMonth)
```
    从一年，一月和一天获得LocalDate的实例。
    这将返回一个LocalDate与指定的年，月和日。该日期必须在年和月中有效，否则将抛出异常。
    
    参数
    
    year - 从MIN_YEAR到MAX_YEAR的年份
    
    month - 从1月1日至12日（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 - 如果任何字段的值超出范围，或者如果当年的日期无效
  - ofInstant
```
public static LocalDate ofInstant(Instant instant,
                                  ZoneId zone)
```
    从Instant和区域ID获取LocalDate的实例。
    这将根据指定的时间创建本地日期。首先，使用区域ID和时刻获取UTC /格林威治的偏移量，这很简单，因为每个时刻只有一个有效的偏移量。然后，使用即时和偏移量来计算本地日期。
    
    参数
    
    instant - 即时创建日期，不为null
    
    zone - 时区，可能是偏移，不为空
    
    结果
    
    本地日期，不为空
    
    异常
    
    DateTimeException - 如果结果超出了支持的范围
    
    从以下版本开始：
    
    9
  - 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的实例。
    这将基于指定的时间获取本地日期。 A TemporalAccessor表示日期和时间信息的任意集合，该工厂将转换为LocalDate的实例。
    
    转换使用TemporalQueries.localDate()查询，它依赖于提取EPOCH_DAY字段。
    
    该方法匹配功能接口TemporalQuery的签名，允许其通过方法参考LocalDate::from用作查询。
    
    参数
    
    temporal - 要转换的时间对象，不为null
    
    结果
    
    本地日期，不为空
    
    异常
    
    DateTimeException - 如果无法转换为 LocalDate
    
    另请参见：
    
    Chronology.date(TemporalAccessor)
  - parse
```
public static LocalDate parse(CharSequence text)
```
    从2007-12-03等文本字符串获取LocalDate的实例。
    字符串必须表示有效的日期，并使用DateTimeFormatter.ISO_LOCAL_DATE进行解析。
    
    参数
    
    text - 要解析的文本，如“2007-12-03”，不为空
    
    结果
    
    解析的本地日期，不为null
    
    异常
    
    DateTimeParseException - 如果文本无法解析
  - parse
```
public static LocalDate parse(CharSequence text,
                              DateTimeFormatter formatter)
```
    使用特定的格式化程序从文本字符串获取LocalDate的实例。
    使用格式化程序解析文本，返回日期。
    
    参数
    
    text - 要解析的文本，不为空
    
    formatter - 要使用的格式化程序，不为空
    
    结果
    
    解析的本地日期，不为null
    
    异常
    
    DateTimeParseException - 如果文本无法解析
  - isSupported
```
public boolean isSupported(TemporalField field)
```
    检查指定的字段是否受支持。
    这将检查是否可以查询指定字段的日期。如果是假，然后调用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 ，则此方法的结果是通过调用得到TemporalField.isSupportedBy(TemporalAccessor)传递this作为参数。字段是否受支持由字段决定。
    Specified by:
    
    isSupported在接口 ChronoLocalDate
    
    Specified by:
    
    isSupported在接口 TemporalAccessor
    
    参数
    
    field - 要检查的字段，null返回false
    
    结果
    
    如果在此日期支持该字段，则为true，否则为false
  - isSupported
```
public boolean isSupported(TemporalUnit unit)
```
    检查指定的单位是否受支持。
    这将检查指定单位是否可以添加到该日期或从该日期减去。如果是false，那么调用plus(long, TemporalUnit)和minus方法就会抛出异常。
    
    如果单位是ChronoUnit，那么查询是在这里实现的。支持的单位是：
    
    DAYS
    
    WEEKS
    
    MONTHS
    
    YEARS
    
    DECADES
    
    CENTURIES
    
    MILLENNIA
    
    ERAS
    
    所有其他ChronoUnit实例将返回false。
    如果该单元不是ChronoUnit ，则此方法的结果是通过调用得到TemporalUnit.isSupportedBy(Temporal)传递this作为参数。设备是否受支持由本机决定。
    Specified by:
    
    isSupported在接口 ChronoLocalDate
    
    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将返回基于此日期的有效值，除了EPOCH_DAY和PROLEPTIC_MONTH ，这些值太大，不符合int并抛出UnsupportedTemporalTypeException 。所有其他ChronoField实例将抛出一个UnsupportedTemporalTypeException 。
    
    如果该字段是不是一个ChronoField ，则此方法的结果是通过调用得到TemporalField.getFrom(TemporalAccessor)传递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 - 如果发生数字溢出
  - getChronology
```
public IsoChronology getChronology()
```
    获取这个日期的时间顺序，即ISO日历系统。
    Chronology代表正在使用的日历系统。 ISO-8601日历系统是当今世界绝大多数的现代民用日历系统。它相当于今天的闰年规则一直适用于日常生活的公历日历系统。
    
    Specified by:
    
    getChronology在接口 ChronoLocalDate
    
    结果
    
    ISO年表，不为空
  - getEra
```
public IsoEra getEra()
```
    获得这个时代适用的时代。
    官方的ISO-8601标准没有定义时间，但是IsoChronology没有。它从一年前开始定义了两个时代的“CE”，从零开始定义了“公元前”。由于Julian-Gregorian割接之前的日期与历史不一致，“BCE”和“CE”之间的切换也不与通常使用“BC”和“AD”的常用的时间对齐。
    
    该类的用户通常应该忽略此方法，因为它主要是为了履行需要支持日文日历系统的ChronoLocalDate合同。
    
    Specified by:
    
    getEra在接口 ChronoLocalDate
    
    结果
    
    此日期适用的IsoEra不为空
  - getYear
```
public int getYear()
```
    获取年份字段。
    此方法返回一年的原始值int 。
    
    通过这种方法返回的年份是按照get(YEAR) 。要获得年代，请使用get(YEAR_OF_ERA) 。
    
    结果
    
    年，从MIN_YEAR到MAX_YEAR
  - getMonthValue
```
public int getMonthValue()
```
    将月份字段从1到12。
    此方法将一个月作为int从1到12返回。如果通过调用getMonth()使用枚举Month，应用程序代码通常会更加清晰。
    
    结果
    
    从1到12年的月份
    
    另请参见：
    
    getMonth()
  - getMonth
```
public Month getMonth()
```
    使用Month枚举获取月份字段。
    此方法返回本月的枚举Month 。这避免了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 value 。
    
    附加信息可以从DayOfWeek获得。这包括值的文本名称。
    
    结果
    
    星期几不为零
  - isLeapYear
```
public boolean isLeapYear()
```
    根据ISO培训日历系统规则，检查年份是否是闰年。
    这种方法在整个时间线上应用目前的闰年规则。一般来说，一年是一个闰年，如果没有余数可以被四分割。但是，除了100岁之外，年份可以被分割为100岁，除了年龄可以被400除外。
    
    例如，1904年是一个闰年，可以被4整除。1900年不是一个闰年，因为它可以被100整除，然而2000年是一个闰年，因为它可以被400除数。
    
    计算是应激的 - 将相同的规则应用到远未来很远的地方。这在历史上是不准确的，但对于ISO-8601标准是正确的。
    
    Specified by:
    
    isLeapYear在接口 ChronoLocalDate
    
    结果
    
    如果一年是飞跃，否则为假
  - lengthOfMonth
```
public int lengthOfMonth()
```
    返回由此日期表示的月份的长度。
    这将以天为单位返回月份的长度。例如，1月份的日期将返回31。
    
    Specified by:
    
    lengthOfMonth在接口 ChronoLocalDate
    
    结果
    
    月的长度以天为单位
  - lengthOfYear
```
public int lengthOfYear()
```
    返回由此日期表示的年份的长度。
    这将返回年份的长度，以天数为365或366。
    
    Specified by:
    
    lengthOfYear在接口 ChronoLocalDate
    
    结果
    
    366如果一年是飞跃，否则为365
  - with
```
public LocalDate with(TemporalAdjuster adjuster)
```
    返回此日期的调整副本。
    这将返回一个LocalDate ，基于这一个，调整日期。调整使用指定的调整器策略对象进行。阅读调整器的文档，了解将进行什么调整。
    
    一个简单的调整器可能只是设置一个字段，如年份字段。更复杂的调整器可能会将日期设置为该月的最后一天。
    
    TemporalAdjusters提供了一些常见的调整。这些包括找到“月的最后一天”和“下周三”。关键的日期时间课程还实现了TemporalAdjuster界面，如Month和MonthDay 。调整员负责处理特殊情况，如月份和闰年的不同长度。
    
    例如这个代码在7月的最后一天返回一个日期：
    
    import static java.time.Month.*; import static java.time.temporal.TemporalAdjusters.*; result = localDate.with(JULY).with(lastDayOfMonth());
    
    该方法的结果是通过调用TemporalAdjuster.adjustInto(Temporal)方法，通过this作为参数的指定调整器。
    
    此实例是不可变的，不受此方法调用的影响。
    Specified by:
    
    with在接口 ChronoLocalDate
    
    Specified by:
    
    with在接口 Temporal
    
    参数
    
    adjuster - 调整器使用，不为空
    
    结果
    
    一个 LocalDate基于 this进行了调整，不为null
    
    异常
    
    DateTimeException - 如果不能进行调整
    
    ArithmeticException - 如果发生数字溢出
  - with
```
public LocalDate with(TemporalField field,
                      long newValue)
```
    返回此日期的副本，并将指定的字段设置为新值。
    这将返回一个LocalDate ，基于此，更改指定字段的值。这可以用于更改任何支持的字段，例如年，月或月。如果不可能设置该值，因为该字段不受支持或出于某种其他原因，则抛出异常。
    
    在某些情况下，更改指定字段可能会导致生成日期无效，例如将月份从1月31日更改为2月将导致日期无效。在这种情况下，该领域负责解决日期。通常，它将选择先前的有效日期，这将是本例中最后一个有效的二月份。
    
    如果该字段是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与指定的LocalDate 。除非新月和年份无效，否则日期不变。在这种情况下，每月的月份将被调整为新的月份和年份的最大有效值。
    
    YEAR_OF_ERA - 返回具有特定年龄的LocalDate 。时代和月份将保持不变。除非新的月份和年份都无效，否则日期也将保持不变。在这种情况下，每月的月份将被调整为新的月份和年份的最大有效值。
    
    YEAR - 返回指定年份的LocalDate 。这个月不变。除非新的月份和年份都无效，否则日期也将保持不变。在这种情况下，每月的月份将被调整为新的月份和年份的最大有效值。
    
    ERA - 返回指定时代的LocalDate 。年份和月份将保持不变。除非新的月份和年份都无效，否则日期也将保持不变。在这种情况下，每月的月份将被调整为新的月份和年份的最大有效值。
    
    在所有情况下，如果新值超出该字段值的有效范围，那么将抛出一个DateTimeException 。
    
    所有其他ChronoField实例都会抛出一个UnsupportedTemporalTypeException 。
    
    如果该字段是不是一个ChronoField ，则此方法的结果是通过调用得到TemporalField.adjustInto(Temporal, long)传递this作为参数。在这种情况下，该字段决定是否以及如何调整即时。
    
    此实例是不可变的，不受此方法调用的影响。
    Specified by:
    
    with在接口 ChronoLocalDate
    
    Specified by:
    
    with在接口 Temporal
    
    参数
    
    field - 要在结果中设置的字段，不为null
    
    newValue - 结果中字段的新值
    
    结果
    
    一个 LocalDate基于 this与指定的字段集，不为null
    
    异常
    
    DateTimeException - 如果该字段无法设置
    
    UnsupportedTemporalTypeException - 如果该字段不被支持
    
    ArithmeticException - 如果发生数字溢出
  - withYear
```
public LocalDate withYear(int year)
```
    返回该LocalDate的副本。
    如果一年中的日期无效，它将被更改为该月的最后一个有效日期。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    year - 设置结果的年份，从MIN_YEAR到MAX_YEAR
    
    结果
    
    一个 LocalDate基于这个日期与请求的年份，不为null
    
    异常
    
    DateTimeException - 如果年值无效
  - withMonth
```
public LocalDate withMonth(int month)
```
    返回该LocalDate的副本。
    如果一年中的日期无效，它将被更改为该月的最后一个有效日期。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    month - 从1月（1月）到12月（12月）的结果中，
    
    结果
    
    一个 LocalDate基于这个日期与请求的月份，不为null
    
    异常
    
    DateTimeException - 如果月份值无效
  - withDayOfMonth
```
public LocalDate withDayOfMonth(int dayOfMonth)
```
    返回此LocalDate的副本，并更改日期。
    如果生成的日期无效，则抛出异常。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    dayOfMonth - 在结果中设置的月份，从1到28-31
    
    结果
    
    一个 LocalDate基于此日期与请求的日期，不为null
    
    异常
    
    DateTimeException - 如果月日的价值无效，或者月的月日无效的月份
  - withDayOfYear
```
public LocalDate withDayOfYear(int dayOfYear)
```
    返回此LocalDate更改的LocalDate的副本。
    如果生成的日期无效，则抛出异常。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    dayOfYear - 设定结果的日期，从1到365-366
    
    结果
    
    一个 LocalDate基于这个日期与请求的一天，不为null
    
    异常
    
    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 - 要添加的金额，不为null
    
    结果
    
    一个 LocalDate基于这个日期与添加，而不是null
    
    异常
    
    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了指定年数的LocalDate 。这相当于plusYears(long) 。除非新月和年份无效，否则月份将不会改变。在这种情况下，每月的月份将被调整为新的月份和年份的最大有效值。
    
    DECADES - 返回一个LocalDate ，加上指定的几十年。这相当于拨打plusYears(long) ，金额乘以10.除非新月和年份无效，否则日期将不变。在这种情况下，每月的月份将被调整为新的月份和年份的最大有效值。
    
    CENTURIES - 返回一个LocalDate ，附加了几百年的指定数量。这相当于拨打plusYears(long) ，金额乘以100.除非新月和年份无效，否则日期将不变。在这种情况下，每月的月份将被调整为新的月份和年份的最大有效值。
    
    MILLENNIA - 返回一个LocalDate ，加上指定的几千年。这相当于拨打plusYears(long) ，数量乘以1,000。除非新月和年份无效，否则月份将不会改变。在这种情况下，每月的月份将被调整为新的月份和年份的最大有效值。
    
    ERAS - 返回一个LocalDate ，其中添加了指定的时间。只支持两个时间，所以数量必须是1，零或者减1。如果金额不是零，那么这个年份就会改变，使得年龄不变。除非新月和年份无效，否则月份将不会改变。在这种情况下，每月的月份将被调整为新的月份和年份的最大有效值。
    
    所有其他ChronoUnit实例将抛出一个UnsupportedTemporalTypeException 。
    
    如果该字段是不是一个ChronoUnit ，则此方法的结果是通过调用得到TemporalUnit.addTo(Temporal, long)传递this作为参数。在这种情况下，单元确定是否以及如何执行添加。
    
    此实例是不可变的，不受此方法调用的影响。
    Specified by:
    
    plus在接口 ChronoLocalDate
    
    Specified by:
    
    plus在接口 Temporal
    
    参数
    
    amountToAdd - 添加到结果中的单位数量可能为负数
    
    unit - 要添加的单位，不为null
    
    结果
    
    一个 LocalDate基于此日期与指定的数量添加，不为null
    
    异常
    
    DateTimeException - 如果不能添加
    
    UnsupportedTemporalTypeException - 如果不支持本机
    
    ArithmeticException - 如果发生数字溢出
  - plusYears
```
public LocalDate plusYears(long yearsToAdd)
```
    返回添加了指定年数的LocalDate的副本。
    该方法通过三个步骤将指定的数量添加到年份字段：
    
    将输入年份添加到年份字段
    
    检查结果日期是否无效
    
    如果有必要，将月份调整到最后一个有效日期
    
    例如，2008-02-29（闰年）加上一年将导致无效日期2009-02-29（标准年）。而不是返回无效结果，而是选择2009-02-28的最后一个有效日期。
    
    此实例是不可变的，不受此方法调用的影响。
    参数
    
    yearsToAdd - 多年来补充，可能是负数
    
    结果
    
    一个 LocalDate基于这个日期与添加的年份，不为null
    
    异常
    
    DateTimeException - 如果结果超出支持的日期范围
  - plusMonths
```
public LocalDate plusMonths(long monthsToAdd)
```
    返回此LocalDate的副本，并附加指定的月数。
    此方法通过三个步骤将指定的数量添加到月份字段：
    
    将输入的月份添加到月份字段
    
    检查结果日期是否无效
    
    如果有必要，将月份调整到最后一个有效日期
    
    例如，2007-03-31加上一个月将导致无效日期2007-04-31。而不是返回无效结果，而是选择2007-04-30的最后一个有效日期。
    
    此实例是不可变的，不受此方法调用的影响。
    参数
    
    monthsToAdd - 要添加的月份，可能为负数
    
    结果
    
    一个 LocalDate基于这个日期与添加的月份，不为null
    
    异常
    
    DateTimeException - 如果结果超出支持的日期范围
  - plusWeeks
```
public LocalDate plusWeeks(long weeksToAdd)
```
    返回此LocalDate的副本，并附加指定的星期数。
    该方法将指定的数量以周为单位，根据需要增加月份和年份字段的日期字段，以确保结果保持有效。如果超过最大/最小年份，结果将无效。
    
    例如，2008-12-31加上一周将导致2009-01-07。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    weeksToAdd - 要添加的星期可能为负数
    
    结果
    
    一个 LocalDate基于这个日期与周添加，不为null
    
    异常
    
    DateTimeException - 如果结果超出支持的日期范围
  - plusDays
```
public LocalDate plusDays(long daysToAdd)
```
    以指定的天数返回此LocalDate的副本。
    此方法将指定的金额添加到天数字段中，根据需要增加月份和年份字段，以确保结果保持有效。如果超过最大/最小年份，结果将无效。
    
    例如，2008-12-31加上一天会导致2009-01-01。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    daysToAdd - 添加的日子可能为负数
    
    结果
    
    一个 LocalDate基于这个日期与添加的日子，不为null
    
    异常
    
    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基于这个日期与减法而不是null
    
    异常
    
    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基于此日期减去指定的数量，不为null
    
    异常
    
    DateTimeException - 如果不能进行减法
    
    UnsupportedTemporalTypeException - 如果不支持本机
    
    ArithmeticException - 如果发生数字溢出
  - minusYears
```
public LocalDate minusYears(long yearsToSubtract)
```
    返回此LocalDate的副本，并减去指定的年数。
    该方法从三个步骤中减去指定的数量：
    
    从年度字段减去输入年数
    
    检查结果日期是否无效
    
    如果有必要，将月份调整到最后一个有效日期
    
    例如，2008-02-29（闰年）减去一年将导致无效日期2007-02-29（标准年）。而不是返回无效结果，而是选择2007-02-28的该月份的最后一个有效日期。
    
    此实例是不可变的，不受此方法调用的影响。
    参数
    
    yearsToSubtract - 减去年份，可能为负数
    
    结果
    
    一个 LocalDate基于这个日期减去，不是null
    
    异常
    
    DateTimeException - 如果结果超出支持的日期范围
  - minusMonths
```
public LocalDate minusMonths(long monthsToSubtract)
```
    返回此LocalDate的副本，并减去指定的月数。
    该方法从以下三个步骤中减去月份字段中指定的数量：
    
    从月份字段减去输入月份
    
    检查结果日期是否无效
    
    如果有必要，将月份调整到最后一个有效日期
    
    例如，2007-03-31减去一个月将导致无效日期2007-02-31。而不是返回无效结果，而是选择2007-02-28的该月份的最后一个有效日期。
    
    此实例是不可变的，不受此方法调用的影响。
    参数
    
    monthsToSubtract - 减去的月份可能为负数
    
    结果
    
    一个 LocalDate基于此日期与减去的月份，不为null
    
    异常
    
    DateTimeException - 如果结果超出支持的日期范围
  - minusWeeks
```
public LocalDate minusWeeks(long weeksToSubtract)
```
    返回此LocalDate的副本，并减去指定的周数。
    该方法从必要的日期字段减去月和年字段中减去指定的数量，以确保结果保持有效。如果超过最大/最小年份，结果将无效。
    
    例如，2009-01-07减去一周将导致2008-12-31。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    weeksToSubtract - 减去的星期可能为负数
    
    结果
    
    一个 LocalDate基于这个日期与减去的星期，不为null
    
    异常
    
    DateTimeException - 如果结果超出支持的日期范围
  - minusDays
```
public LocalDate minusDays(long daysToSubtract)
```
    返回此LocalDate的副本，并减去指定的天数。
    该方法根据需要减去月份和年份字段的日期字段减去指定的金额，以确保结果保持有效。如果超过最大/最小年份，结果将无效。
    
    例如，2009-01-01减去一天会导致2008-12-31。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    daysToSubtract - 减去的日子可能是负数
    
    结果
    
    一个 LocalDate基于这个日期减去，而不是null
    
    异常
    
    DateTimeException - 如果结果超出支持的日期范围
  - query
```
public <R> R query(TemporalQuery<R> query)
```
    使用指定的查询查询此日期。
    这使用指定的查询策略对象查询此日期。 TemporalQuery对象定义了用于获取结果的逻辑。阅读查询的文档，以了解该方法的结果。
    
    该方法的结果是通过调用TemporalQuery.queryFrom(TemporalAccessor)方法获得的指定查询通过this作为参数。
    
    Specified by:
    
    query在接口 ChronoLocalDate
    
    Specified by:
    
    query在接口 TemporalAccessor
    
    参数类型
    
    R - 结果的类型
    
    参数
    
    query - 要调用的查询，不为空
    
    结果
    
    查询结果可能返回null（由查询定义）
    
    异常
    
    DateTimeException - 如果无法查询（由查询定义）
    
    ArithmeticException - 如果发生数字溢出（由查询定义）
  - adjustInto
```
public Temporal adjustInto(Temporal temporal)
```
    调整指定的时间对象与此对象的日期相同。
    这返回与日期改变为与之相同的输入的相同可观察类型的时间对象。
    
    该调整是相当于使用Temporal.with(TemporalField, long)通过ChronoField.EPOCH_DAY作为字段。
    
    在大多数情况下，通过使用Temporal.with(TemporalAdjuster)来更正呼叫模式：
    
    // these two lines are equivalent, but the second approach is recommended temporal = thisLocalDate.adjustInto(temporal); temporal = temporal.with(thisLocalDate);
    
    此实例是不可变的，不受此方法调用的影响。
    Specified by:
    
    adjustInto在接口 ChronoLocalDate
    
    Specified by:
    
    adjustInto在接口 TemporalAdjuster
    
    参数
    
    temporal - 要调整的目标对象，不为null
    
    结果
    
    调整对象，不为null
    
    异常
    
    DateTimeException - 如果不能进行调整
    
    ArithmeticException - 如果发生数字溢出
  - until
```
public long until(Temporal endExclusive,
                  TemporalUnit unit)
```
    根据指定的单位计算直到另一个日期的时间量。
    这将计算一个LocalDate对象之间的时间量，单个TemporalUnit 。起点和终点为this和指定日期。如果结束在开始之前，结果将为负数。所述Temporal传递给此方法被转换为LocalDate使用from(TemporalAccessor) 。例如，可以使用startDate.until(endDate, DAYS)计算两个日期之间的天startDate.until(endDate, DAYS) 。
    
    计算返回一个整数，表示两个日期之间的完整单位数。例如，2012-06-15至2012-08-14之间的月数将只有一个月，因为是两个月的一天。
    
    使用这种方法有两种等效的方法。第一个是调用这个方法。二是使用TemporalUnit.between(Temporal, Temporal) ：
    
    // these two lines are equivalent amount = start.until(end, MONTHS); amount = MONTHS.between(start, end);
    应该根据这种做法进行选择，使代码更易读。
    该方法的计算用于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和指定的日期。如果结束在开始之前，结果将为负数。每年，每月的负号将相同。
    
    使用ISO日历系统进行计算。如有必要，输入日期将转换为ISO。
    
    包含开始日期，但结束日期不是。通过删除完整的月份计算该期间，然后计算剩余天数，进行调整，以确保两者都具有相同的符号。然后根据12个月的时间将月数标准化为数年和数月。如果结束日期的月份大于或等于开始的日期，则一个月被认为是完整的。例如，从2010-01-15到2011-03-18是“1年，2个月和3天”。
    
    使用这种方法有两种等效的方法。第一个是调用这个方法。二是使用Period.between(LocalDate, LocalDate) ：
    
    // these two lines are equivalent period = start.until(end); period = Period.between(start, end);
    应该根据这种做法进行选择，使代码更易读。
    Specified by:
    
    until在接口 ChronoLocalDate
    
    参数
    
    endDateExclusive - 结束日期，排他，可能在任何年代，不为空
    
    结果
    
    此日期与结束日期之间的期间不为空
  - datesUntil
```
public Stream<LocalDate> datesUntil(LocalDate endExclusive)
```
    返回顺序排列的日期流。返回的流从此日期开始（包括），并以1天的增量步长进入endExclusive （排他）。
    此方法相当于datesUntil(endExclusive, Period.ofDays(1)) 。
    
    参数
    
    endExclusive - 结束日期，排他，不为空
    
    结果
    
    一个序列 Stream的范围为 LocalDate值
    
    异常
    
    IllegalArgumentException - 如果结束日期在此日期之前
    
    从以下版本开始：
    
    9
  - datesUntil
```
public Stream<LocalDate> datesUntil(LocalDate endExclusive,
                                    Period step)
```
    通过给定的增量步骤返回日期的顺序排序流。返回的流从此日期开始（包括），并转到endExclusive （排他）。
    流中出现的第n个日期等于this.plus(step.multipliedBy(n)) （但步进乘法的结果永远不会溢出）。例如，如果这个日期是2015-01-31 ，结束日期是2015-05-01和步骤为1个月，然后流包含2015-01-31 ， 2015-02-28 ， 2015-03-31 ，和2015-04-30 。
    
    参数
    
    endExclusive - 结束日期，排他，不为null
    
    step - 代表步骤的非零，非负 Period 。
    
    结果
    
    一个序列 Stream的范围为 LocalDate值
    
    异常
    
    IllegalArgumentException - 如果步数为零，或 step.getDays()和 step.toTotalMonths()具有相反的符号，或结束日期在此日期之前，步骤为正，或结束日期为此日期之后，步骤为负
    
    从以下版本开始：
    
    9
  - format
```
public String format(DateTimeFormatter formatter)
```
    使用指定的格式化程序格式化此日期。
    此日期将传递给格式化程序以生成一个字符串。
    
    Specified by:
    
    format在接口 ChronoLocalDate
    
    参数
    
    formatter - 要使用的格式化程序，不为null
    
    结果
    
    格式化的日期字符串，不为null
    
    异常
    
    DateTimeException - 打印过程中是否发生错误
  - atTime
```
public LocalDateTime atTime(LocalTime time)
```
    结合这个日期与时间创建一个LocalDateTime 。
    这将在指定的时间返回从此日期形成的LocalDateTime 。日期和时间的所有可能的组合都是有效的。
    
    Specified by:
    
    atTime在接口 ChronoLocalDate
    
    参数
    
    time - 结合的时间，不为null
    
    结果
    
    从该日期到指定时间形成的本地日期时间，不为空
  - 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到999,999,999的纳秒
    
    结果
    
    从该日期到指定时间形成的本地日期时间，不为空
    
    异常
    
    DateTimeException - 如果任何字段的值超出范围
  - atTime
```
public OffsetDateTime atTime(OffsetTime time)
```
    将此日期与偏移时间相结合以创建OffsetDateTime 。
    这将在指定的时间返回从此日期形成的OffsetDateTime 。日期和时间的所有可能的组合都是有效的。
    
    参数
    
    time - 结合的时间，不为null
    
    结果
    
    从该日期和指定时间形成的偏移日期时间，不为空
  - atStartOfDay
```
public LocalDateTime atStartOfDay()
```
    将此日期与午夜时间相结合，以便在此日期开始时创建一个LocalDateTime 。
    这将在此日期开始之前的午夜00:00之间返回一个LocalDateTime 。
    
    结果
    
    本日期开始的午夜的当地日期时间不为空
  - atStartOfDay
```
public ZonedDateTime atStartOfDay(ZoneId zone)
```
    根据时区中的规则，在最早的有效时间内从此日期返回划分的日期时间。
    时区规则（如夏令时）意味着不是每个本地日期时间对指定的区域都有效，因此本地日期时间可能不是午夜。
    
    在大多数情况下，本地日期时间只有一个有效的偏移量。在重叠的情况下，存在两个有效的偏移量，并且使用较早的一个，对应于该日期的午夜的第一次出现。在差距的情况下，分区的日期时间将代表差距之后的时刻。
    
    如果区域ID为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
    
    结果
    
    大纪元日等于这个日期
  - toEpochSecond
```
public long toEpochSecond(LocalTime time,
                          ZoneOffset offset)
```
    将此LocalDate转换为1970-01-01T00：00：00Z的时代以来的秒数。
    这将此本地日期与指定的时间和偏移量相结合，以计算从1970-01-01T00：00：00Z开始的秒数。时代之后的时代的实体是积极的，较早的是负的。
    
    参数
    
    time - 当地时间，不为空
    
    offset - 区域偏移，不为空
    
    结果
    
    从1970-01-01T00：00：00Z开始的秒数可能为负数
    
    从以下版本开始：
    
    9
  - compareTo
```
public int compareTo(ChronoLocalDate other)
```
    将此日期与另一个日期进行比较。
    比较主要是从最早到最晚的日期。它与“等于”一致，如Comparable所定义。
    
    如果所有被比较的日期都是LocalDate实例，则比较将完全基于日期。如果一些比较的日期是不同的年表，那么年龄也被考虑，见ChronoLocalDate.compareTo(java.time.chrono.ChronoLocalDate) 。
    
    Specified by:
    
    compareTo在接口 ChronoLocalDate
    
    Specified by:
    
    compareTo在接口 Comparable<ChronoLocalDate>
    
    参数
    
    other - 与之比较的其他日期，不为空
    
    结果
    
    比较器值为负，如果较小，则如果较大则为正
  - isAfter
```
public boolean isAfter(ChronoLocalDate other)
```
    检查此日期是否在指定日期之后。
    这将检查这个日期是否表示在另一个日期之后的本地时间线上的一个点。
    
    LocalDate a = LocalDate.of(2012, 6, 30); LocalDate b = LocalDate.of(2012, 7, 1); a.isAfter(b) == false a.isAfter(a) == false b.isAfter(a) == true
    
    此方法仅考虑两个日期在本地时间线上的位置。它不考虑年表或日历系统。这与compareTo(ChronoLocalDate)中的比较不同，但是与ChronoLocalDate.timeLineOrder()相同。
    Specified by:
    
    isAfter在接口 ChronoLocalDate
    
    参数
    
    other - 与之比较的其他日期，不为null
    
    结果
    
    如果此日期在指定日期之后，则为真
  - isBefore
```
public boolean isBefore(ChronoLocalDate other)
```
    检查此日期是否在指定日期之前。
    这将检查该日期是否表示在另一个日期之前的本地时间线上的一个点。
    
    LocalDate a = LocalDate.of(2012, 6, 30); LocalDate b = LocalDate.of(2012, 7, 1); a.isBefore(b) == true a.isBefore(a) == false b.isBefore(a) == false
    
    此方法仅考虑两个日期在本地时间线上的位置。它不考虑年表或日历系统。这与compareTo(ChronoLocalDate)中的比较不同，但是与ChronoLocalDate.timeLineOrder()相同。
    Specified by:
    
    isBefore在接口 ChronoLocalDate
    
    参数
    
    other - 要比较的其他日期，不为null
    
    结果
    
    如果此日期在指定日期之前，则为真
  - isEqual
```
public boolean isEqual(ChronoLocalDate other)
```
    检查此日期是否等于指定的日期。
    这将检查该日期是否表示与其他日期在当地时间线上的相同点。
    
    LocalDate a = LocalDate.of(2012, 6, 30); LocalDate b = LocalDate.of(2012, 7, 1); a.isEqual(b) == false a.isEqual(a) == true b.isEqual(a) == false
    
    此方法仅考虑两个日期在本地时间线上的位置。它不考虑年表或日历系统。这是在比较不同compareTo(ChronoLocalDate) ，但是同样的方法为ChronoLocalDate.timeLineOrder() 。
    Specified by:
    
    isEqual在接口 ChronoLocalDate
    
    参数
    
    other - 要比较的其他日期，不为空
    
    结果
    
    如果此日期等于指定日期，则为真
  - equals
```
public boolean equals(Object obj)
```
    检查这个日期是否等于另一个日期。
    比较这个LocalDate与另一个确保日期是一样的。
    
    只对LocalDate类型的LocalDate进行比较，其他类型返回false。要比较两个TemporalAccessor实例的日期，包括两个不同年表中的日期，请使用ChronoField.EPOCH_DAY作为比较。
    
    Specified by:
    
    equals在接口 ChronoLocalDate
    
    重写：
    
    equals在 Object
    
    参数
    
    obj - 要检查的对象，null返回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 。
    输出将采用ISO-8601格式uuuu-MM-dd 。
    
    Specified by:
    
    toString在接口 ChronoLocalDate
    
    重写：
    
    toString在 Object
    
    结果
    
    此日期的字符串表示形式，不为null

Class LocalDate

Field Summary

方法摘要

Methods inherited from interface java.time.chrono.ChronoLocalDate

Methods inherited from class java.lang.Object

字段详细信息

MIN

MAX

EPOCH

方法详细信息

now

now

now

of

of

ofYearDay

ofInstant

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

datesUntil

datesUntil

format

atTime

atTime

atTime

atTime

atTime

atStartOfDay

atStartOfDay

toEpochDay

toEpochSecond

compareTo

isAfter

isBefore

isEqual

equals

hashCode

toString