实现的所有接口

Serializable ， Comparable<ChronoLocalDate> ， ChronoLocalDate ， Temporal ， TemporalAccessor ， TemporalAdjuster
```
public final class LocalDateextends Objectimplements 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

字段汇总

字段
变量和类型	字段	描述
`static LocalDate`	`EPOCH`	纪元年 `LocalDate` ，'1970-01-01'。
`static LocalDate`	`MAX`	最大支持 `LocalDate` ，'+ 999999999-12-31'。
`static LocalDate`	`MIN`	支持的最小值为 `LocalDate` ，' - `LocalDate` '。

方法摘要

所有方法静态方法实例方法具体的方法
变量和类型	方法	描述
`Temporal`	`adjustInto(Temporal temporal)`	将指定的时态对象调整为与此对象具有相同的日期。
`LocalDateTime`	`atStartOfDay()`	将此日期与午夜时间相结合，可在此日期开始时创建 `LocalDateTime` 。
`ZonedDateTime`	`atStartOfDay(ZoneId zone)`	根据时区中的规则，在最早的有效时间返回此日期的分区日期时间。
`LocalDateTime`	`atTime(int hour, int minute)`	将此日期与创建 `LocalDateTime`的时间相 `LocalDateTime` 。
`LocalDateTime`	`atTime(int hour, int minute, int second)`	将此日期与创建 `LocalDateTime`的时间相 `LocalDateTime` 。
`LocalDateTime`	`atTime(int hour, int minute, int second, int nanoOfSecond)`	将此日期与创建 `LocalDateTime`的时间相 `LocalDateTime` 。
`LocalDateTime`	`atTime(LocalTime time)`	将此日期与创建 `LocalDateTime`的时间相 `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`	`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`	`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`	`withMonth(int month)`	返回此 `LocalDate`的副本，其中年份已更改。
`LocalDate`	`withYear(int year)`	返回此 `LocalDate`的副本，并更改年份。

声明方法的类 java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

声明方法的接口 java.time.chrono.ChronoLocalDate
toEpochDay

- 字段详细信息
  - MIN
```
public static final LocalDate MIN
```
    支持的最小值为LocalDate ，' - 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 - 要使用的时钟，不为空
    
    结果
    
    当前日期，不为空
  - 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（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和offset来计算本地日期。
    
    参数
    
    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的实例。
    这基于指定的时间获得本地日期。 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
    
    结果
    
    解析的本地日期，而不是null
    
    异常
    
    DateTimeParseException - 如果无法解析文本
  - parse
```
public static LocalDate parse(CharSequence text,                              DateTimeFormatter formatter)
```
    使用特定格式化程序从文本字符串中获取LocalDate的实例。
    使用格式化程序解析文本，返回日期。
    
    参数
    
    text - 要解析的文本，而不是null
    
    formatter - 要使用的格式化程序，不为null
    
    结果
    
    解析的本地日期，而不是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
    
    参数
    
    字段 - 要检查的字段，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
    
    结果
    
    如果可以添加/减去单位，则为true，否则为false
  - range
```
public ValueRange range(TemporalField field)
```
    获取指定字段的有效值范围。
    范围对象表示字段的最小和最大有效值。此日期用于提高返回范围的准确性。如果无法返回范围，因为不支持该字段或由于某些其他原因，将引发异常。
    
    如果该字段是ChronoField，则在此处执行查询。 supported fields将返回适当的范围实例。所有其他ChronoField实例将抛出UnsupportedTemporalTypeException 。
    
    如果该字段是不是一个ChronoField ，则此方法的结果是通过调用获得TemporalField.rangeRefinedBy(TemporalAccessor)传递this作为参数。是否可以获得范围由该字段确定。
    
    Specified by:
    
    range在界面 TemporalAccessor
    
    参数
    
    字段 - 要查询范围的字段，而不是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
    
    参数
    
    字段 - 要获取的字段，而不是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
    
    参数
    
    字段 - 要获取的字段，而不是null
    
    结果
    
    该字段的值
    
    异常
    
    DateTimeException - 如果无法获取该字段的值
    
    UnsupportedTemporalTypeException - 如果不支持该字段
    
    ArithmeticException - 如果发生数字溢出
  - getChronology
```
public IsoChronology getChronology()
```
    获取此日期的年表，即ISO日历系统。
    Chronology表示正在使用的日历系统。 ISO-8601日历系统是当今世界大部分地区使用的现代民用日历系统。它等同于公历的格里高利历法系统，其中今天的闰年规则一直适用。
    
    Specified by:
    
    getChronology在界面 ChronoLocalDate
    
    结果
    
    ISO年表，不是null
  - getEra
```
public IsoEra getEra()
```
    获取此日期适用的时代。
    官方的ISO-8601标准没有定义时代，但IsoChronology确实如此。它定义了两个时代，从第一年开始的'CE'和从零年后的'BCE'。由于Julian-Gregorian转换之前的日期与历史不符，因此'BCE'和'CE'之间的转换也与常用的时代不一致，通常使用'BC'和'AD'。
    
    此类用户通常应忽略此方法，因为它主要用于满足需要支持日语日历系统的ChronoLocalDate合同。
    
    Specified by:
    
    getEra接口 ChronoLocalDate
    
    结果
    
    在此日期适用的IsoEra，不为空
  - getYear
```
public int getYear()
```
    获取年份字段。
    此方法返回年份的原始值int 。
    
    根据get(YEAR) ，此方法返回的年份是get(YEAR) 。要获得年代，请使用get(YEAR_OF_ERA) 。
    
    结果
    
    年份，从MIN_YEAR到MAX_YEAR
  - getMonthValue
```
public int getMonthValue()
```
    获取1到12之间的月份字段。
    此方法将月份作为int从1返回到12.如果通过调用4374410544073使用枚举Month，则应用程序代码通常更清晰。
    
    结果
    
    月份，从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符号日历系统规则，检查年份是否为闰年。
    此方法在整个时间线上应用闰年的当前规则。一般来说，一年是闰年，如果它可以被4整除而没有余数。然而，可以被100整除的年份不是闰年，除了可以被400整除的年份。
    
    例如，1904年是闰年，它可以被4整除.1900不是闰年，因为它可以被100整除，但2000年是闰年，因为它可以被400整除。
    
    计算是渐近的 - 将相同的规则应用到遥远的未来和远期。这在历史上是不准确的，但对于ISO-8601标准是正确的。
    
    Specified by:
    
    isLeapYear在界面 ChronoLocalDate
    
    结果
    
    如果年份是飞跃则为true，否则为false
  - 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 - 要使用的调整器，不为null
    
    结果
    
    一个 LocalDate基于 this与制造，不为空调整
    
    异常
    
    DateTimeException - 如果无法进行调整
    
    ArithmeticException - 如果发生数字溢出
  - with
```
public LocalDate with(TemporalField field,                      long newValue)
```
    返回此日期的副本，并将指定的字段设置为新值。
    这将返回LocalDate （基于此值），并更改指定字段的值。这可用于更改任何支持的字段，例如年，月或日。如果无法设置该值，因为不支持该字段或由于某些其他原因，将引发异常。
    
    在某些情况下，更改指定字段可能会导致生成日期无效，例如将月份从1月31日更改为2月将使日期无效。在这种情况下，该字段负责解决日期。通常，它会选择上一个有效日期，这个日期是本例中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 - 返回带有指定的proleptic-month的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
    
    参数
    
    字段 - 要在结果中设置的字段，不为null
    
    newValue - 结果中字段的新值
    
    结果
    
    一个 LocalDate基于 this使用指定的字段设置，不为空
    
    异常
    
    DateTimeException - 如果无法设置该字段
    
    UnsupportedTemporalTypeException - 如果不支持该字段
    
    ArithmeticException - 如果发生数字溢出
  - withYear
```
public LocalDate withYear(int year)
```
    返回此LocalDate的副本，并更改年份。
    如果该年的某一天无效，则会将其更改为该月的最后一个有效日期。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    year - 结果中设置的年份，从MIN_YEAR到MAX_YEAR
    
    结果
    
    基于此日期与请求年份的 LocalDate ，不为空
    
    异常
    
    DateTimeException - 如果年份值无效
  - withMonth
```
public LocalDate withMonth(int month)
```
    返回此LocalDate的副本，其中年份已更改。
    如果该年的某一天无效，则会将其更改为该月的最后一个有效日期。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    month - 结果中设置的月份，从1（1月）到12（12月）
    
    结果
    
    a LocalDate基于此日期与请求的月份，不为空
    
    异常
    
    DateTimeException - 如果月份值无效
  - withDayOfMonth
```
public LocalDate withDayOfMonth(int dayOfMonth)
```
    返回此LocalDate的副本，并更改日期。
    如果生成的日期无效，则抛出异常。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    dayOfMonth - 结果中设置的日期，从1到28-31
    
    结果
    
    基于此日期与请求日期的 LocalDate ，不为空
    
    异常
    
    DateTimeException - 如果日期值无效，或者月份的月份无效
  - withDayOfYear
```
public LocalDate withDayOfYear(int dayOfYear)
```
    返回此LocalDate的副本，并更改日期。
    如果生成的日期无效，则抛出异常。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    dayOfYear - 在结果中设置的日期，从1到365-366
    
    结果
    
    基于此日期与请求日期的 LocalDate ，不为空
    
    异常
    
    DateTimeException - 如果日期值无效，或者年度日期无效
  - plus
```
public LocalDate plus(TemporalAmount amountToAdd)
```
    返回此日期的副本，并添加指定的数量。
    这将返回基于此值的LocalDate ，并添加指定的数量。金额通常为Period，但可以是实现TemporalAmount接口的任何其他类型。
    
    通过调用TemporalAmount.addTo(Temporal)将计算委托给amount对象。实施金额可以任意方式自由实施，但通常会回拨plus(long, TemporalUnit) 。请参阅金额实施的文档，以确定是否可以成功添加。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    plus ，界面 ChronoLocalDate
    
    Specified by:
    
    plus在界面 Temporal
    
    参数
    
    amountToAdd - 要添加的金额，而不是空
    
    结果
    
    a LocalDate基于此日期添加，不为空
    
    异常
    
    DateTimeException - 如果无法添加
    
    ArithmeticException - 如果发生数字溢出
  - plus
```
public LocalDate plus(long amountToAdd,                      TemporalUnit unit)
```
    返回此日期的副本，并添加指定的数量。
    这将返回基于此值的LocalDate ，其中包含已添加单位的金额。如果无法添加金额，因为不支持该单位或由于某些其他原因，则会引发异常。
    
    在某些情况下，添加金额可能会导致生成的日期无效。例如，将1月31日的一个月添加到2月31日。在这种情况下，该单位负责解决日期。通常，它会选择上一个有效日期，这个日期是本例中2月的最后一个有效日期。
    
    如果该字段是ChronoUnit，则在此处实施添加。支持的字段表现如下：
    
    DAYS - 返回指定天数的LocalDate 。这相当于plusDays(long) 。
    
    WEEKS - 返回一个指定周数的LocalDate 。这相当于plusWeeks(long)并使用7天工作周。
    
    MONTHS - 返回指定月数的LocalDate 。这相当于plusMonths(long) 。除非新月和年无效，否则日期将保持不变。在这种情况下，将日期调整为新月和年的最大有效值。
    
    YEARS - 返回添加了指定年数的LocalDate 。这相当于plusYears(long) 。除非新月和年无效，否则日期将保持不变。在这种情况下，将日期调整为新月和年的最大有效值。
    
    DECADES - 返回添加了指定数十年的LocalDate 。这相当于调用plusYears(long) ，金额乘以10.除非新月和年无效，否则日期将保持不变。在这种情况下，将日期调整为新月和年的最大有效值。
    
    CENTURIES - 返回一个指定了几个世纪的LocalDate 。这相当于拨打plusYears(long) ，金额乘以100.除非新月和年无效，否则日期将保持不变。在这种情况下，将日期调整为新月和年的最大有效值。
    
    MILLENNIA - 返回一个LocalDate ，其中添加了指定的千年数。这相当于调用plusYears(long) ，金额乘以1,000。除非新月和年无效，否则日期将保持不变。在这种情况下，将日期调整为新月和年的最大有效值。
    
    ERAS - 返回一个LocalDate ，其中添加了指定的LocalDate数。仅支持两个时代，因此金额必须为一，零或负一。如果金额不为零，则改变年份，使得年龄不变。除非新月和年无效，否则日期将保持不变。在这种情况下，将日期调整为新月和年的最大有效值。
    
    所有其他ChronoUnit实例将抛出UnsupportedTemporalTypeException 。
    
    如果该字段不是ChronoUnit ，则通过调用TemporalUnit.addTo(Temporal, long)传递this作为参数来获得此方法的结果。在这种情况下，该单元确定是否以及如何执行添加。
    
    此实例是不可变的，不受此方法调用的影响。
    Specified by:
    
    plus在界面 ChronoLocalDate
    
    Specified by:
    
    plus in interface Temporal
    
    参数
    
    amountToAdd - 要添加到结果中的单位数量可能为负数
    
    unit - 要添加的金额的单位，而不是空
    
    结果
    
    基于此日期的 LocalDate ，添加了指定的金额，而不是空
    
    异常
    
    DateTimeException - 如果无法添加
    
    UnsupportedTemporalTypeException - 如果不支持该装置
    
    ArithmeticException - 如果发生数字溢出
  - plusYears
```
public LocalDate plusYears(long yearsToAdd)
```
    返回此LocalDate的副本，并添加指定的年数。
    此方法分三个步骤将指定的金额添加到年份字段：
    
    将输入年份添加到年份字段
    
    检查结果日期是否无效
    
    如有必要，将日期调整为最后一个有效日期
    
    例如，2008-02-29（闰年）加上一年将导致无效日期2009-02-29（标准年份）。而不是返回无效结果，而是选择该月的最后一个有效日期2009-02-28。
    
    此实例是不可变的，不受此方法调用的影响。
    参数
    
    yearsToAdd - 添加的年份，可能是负面的
    
    结果
    
    基于此日期的 LocalDate ，添加年份，不为空
    
    异常
    
    DateTimeException - 如果结果超出支持的日期范围
  - plusMonths
```
public LocalDate plusMonths(long monthsToAdd)
```
    返回此LocalDate的副本，并添加指定的月数。
    此方法分三个步骤将指定的数量添加到months字段：
    
    将输入月份添加到年度字段中
    
    检查结果日期是否无效
    
    如有必要，将日期调整为最后一个有效日期
    
    例如，2007-03-31加上一个月将导致2007-04-31无效日期。而不是返回无效结果，而是选择该月的最后一个有效日期，即2007-04-30。
    
    此实例是不可变的，不受此方法调用的影响。
    参数
    
    monthsToAdd - 要添加的月份，可能是负数
    
    结果
    
    基于此日期的 LocalDate ，添加月份，不为空
    
    异常
    
    DateTimeException - 如果结果超出支持的日期范围
  - plusWeeks
```
public LocalDate plusWeeks(long weeksToAdd)
```
    返回此LocalDate的副本，并添加指定的周数。
    此方法将指定的周数添加到days字段中，根据需要递增月份和年份字段，以确保结果保持有效。结果仅在超过最大/最小年份时无效。
    
    例如，2008-12-31加上一周将导致2009-01-07。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    weeksToAdd - 要添加的周数，可能是负数
    
    结果
    
    基于此日期的 LocalDate ，添加周数，不为空
    
    异常
    
    DateTimeException - 如果结果超出支持的日期范围
  - plusDays
```
public LocalDate plusDays(long daysToAdd)
```
    返回此LocalDate的副本，并添加指定的天数。
    此方法将指定的金额添加到days字段，根据需要递增月份和年份字段，以确保结果保持有效。结果仅在超过最大/最小年份时无效。
    
    例如，2008-12-31加上一天将导致2009-01-01。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    daysToAdd - 添加的日期，可能是负面的
    
    结果
    
    基于此日期的 LocalDate ，添加日期，不为空
    
    异常
    
    DateTimeException - 如果结果超出支持的日期范围
  - minus
```
public LocalDate minus(TemporalAmount amountToSubtract)
```
    返回此日期的副本，并减去指定的数量。
    这将返回一个LocalDate ，基于此值，减去指定的数量。金额通常为Period，但可以是实现TemporalAmount界面的任何其他类型。
    
    通过调用TemporalAmount.subtractFrom(Temporal)将计算委托给amount对象。实现量可以以任何方式自由地实现减法，但是它通常会回调到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的副本，并减去指定的年数。
    此方法分三个步骤从年份字段中减去指定的金额：
    
    从年份字段中减去输入年份
    
    检查结果日期是否无效
    
    如有必要，将日期调整为最后一个有效日期
    
    例如，2008-02-29（闰年）减去一年将导致无效日期2007-02-29（标准年份）。而不是返回无效结果，而是选择该月的最后一个有效日期，即2007-02-28。
    
    此实例是不可变的，不受此方法调用的影响。
    参数
    
    yearsToSubtract - 减去的年份，可能是负数
    
    结果
    
    基于此日期的 LocalDate减去年份，而不是空
    
    异常
    
    DateTimeException - 如果结果超出支持的日期范围
  - minusMonths
```
public LocalDate minusMonths(long monthsToSubtract)
```
    返回此LocalDate的副本，并减去指定的月数。
    此方法分三个步骤从months字段中减去指定的金额：
    
    从月份字段中减去输入月份
    
    检查结果日期是否无效
    
    如有必要，将日期调整为最后一个有效日期
    
    例如，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的副本，并减去指定的天数。
    此方法从日期字段中减去指定的金额，根据需要减少月份和年份字段，以确保结果保持有效。结果仅在超过最大/最小年份时无效。
    
    例如，2009-01-01减去一天将导致2008-12-31。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    daysToSubtract - 减去的日期，可能是负数
    
    结果
    
    基于此日期的 LocalDate ，减去天数，不为空
    
    异常
    
    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
    
    结果
    
    查询结果，可以返回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
    
    结果
    
    调整后的对象，不为空
    
    异常
    
    DateTimeException - 如果无法进行调整
    
    ArithmeticException - 如果发生数字溢出
  - until
```
public long until(Temporal endExclusive,                  TemporalUnit unit)
```
    根据指定的单位计算到另一个日期的时间量。
    这将根据单个TemporalUnit计算两个LocalDate对象之间的时间量。起点和终点是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 - 结束日期，独占，非空
    
    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 。
    这将返回在指定时间从此日期LocalDateTime形成的LocalDateTime 。所有可能的日期和时间组合均有效。
    
    Specified by:
    
    atTime ，界面 ChronoLocalDate
    
    参数
    
    time - 与...结合的时间，而不是null
    
    结果
    
    从此日期和指定时间形成的本地日期时间，不为空
  - atTime
```
public LocalDateTime atTime(int hour,                            int minute)
```
    将此日期与创建LocalDateTime的时间相LocalDateTime 。
    这将返回在指定的小时和分钟从此日期LocalDateTime形成的LocalDateTime 。秒和纳秒字段将设置为零。各个时间字段必须在其有效范围内。所有可能的日期和时间组合均有效。
    
    参数
    
    hour - 使用日期，从0到23
    
    minute - 使用的分钟数，从0到59
    
    结果
    
    从此日期和指定时间形成的本地日期时间，不为空
    
    异常
    
    DateTimeException - 如果任何字段的值超出范围
  - atTime
```
public LocalDateTime atTime(int hour,                            int minute,                            int second)
```
    将此日期与创建LocalDateTime的时间相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 。
    这将返回从该日期在指定的小时，分钟，秒和纳秒处形成的LocalDateTime 。各个时间字段必须在其有效范围内。所有可能的日期和时间组合均有效。
    
    参数
    
    hour - 使用的小时，从0到23
    
    minute - 使用的分钟数，从0到59
    
    second - 代表的第二分钟，从0到59
    
    nanoOfSecond - 代表的纳秒数，从0到999,999,999
    
    结果
    
    从此日期和指定时间形成的本地日期时间，不为空
    
    异常
    
    DateTimeException - 如果任何字段的值超出范围
  - atTime
```
public OffsetDateTime atTime(OffsetTime time)
```
    将此日期与偏移时间组合以创建OffsetDateTime 。
    这将返回在指定时间从此日期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，不为空
    
    结果
    
    从此日期开始的分区日期时间和区域的最早有效时间，不为空
  - 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 in interface Comparable<ChronoLocalDate>
    
    参数
    
    other - 要比较的其他日期，而不是null
    
    结果
    
    比较器值，如果更小则为负，如果更大则为正
  - 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
    
    结果
    
    如果此日期在指定日期之后，则为true
  - 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
    
    结果
    
    如果此日期在指定日期之前，则为true
  - 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 - 要比较的另一个日期，而不是null
    
    结果
    
    如果此日期等于指定日期，则为true
  - equals
```
public boolean equals(Object obj)
```
    检查此日期是否等于另一个日期。
    将此LocalDate与另一个进行比较，确保日期相同。
    
    仅比较类型为LocalDate对象，其他类型返回false。要比较两个TemporalAccessor实例的日期，包括两个不同年代的日期，请使用ChronoField.EPOCH_DAY作为比较器。
    
    Specified by:
    
    equals在界面 ChronoLocalDate
    
    重写：
    
    equals在课程 Object
    
    参数
    
    obj - 要检查的对象，null返回false
    
    结果
    
    如果这等于另一个日期，则为true
    
    另请参见：
    
    Object.hashCode() ， HashMap
  - hashCode
```
public int hashCode()
```
    此日期的哈希码。
    
    Specified by:
    
    hashCode在界面 ChronoLocalDate
    
    重写：
    
    hashCode in class 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

字段汇总

方法摘要

声明方法的类 java.lang.Object

声明方法的接口 java.time.chrono.ChronoLocalDate

字段详细信息

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

toEpochSecond

compareTo

isAfter

isBefore

isEqual

equals

hashCode

toString