模块 java.base
包 java.time

类 LocalDate

java.lang.Object
java.time.LocalDate
所有已实现的接口：
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 日历系统是当今世界大部分地区使用的现代民用日历系统。它相当于公历系统，在所有时间都适用今天的闰年规则。对于当今编写的大多数应用程序，ISO-8601 规则完全适用。然而，任何使用历史日期并要求它们准确的应用程序都会发现 ISO-8601 方法不合适。

这是一个value-based类；程序员应该将 equal 的实例视为可互换的，并且不应使用实例进行同步，否则可能会发生不可预测的行为。例如，在未来的版本中，同步可能会失败。 equals 方法应该用于比较。

实现要求：
这个类是不可变的和线程安全的。
自从：
1.8
参见：

  • 字段详细信息

    • MIN

      public static final LocalDate  MIN
      支持的最小值 LocalDate，'-999999999-01-01'。这可以被应用程序用作“很久以前”的日期。

    • MAX

      public static final LocalDate  MAX
      最大支持 LocalDate ，'+999999999-12-31'。这可以被应用程序用作“遥远的未来”日期。

    • EPOCH

      public static final LocalDate  EPOCH
      纪元年 LocalDate，'1970-01-01'。
      自从：
      9

  • 方法详情

    • 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。 day-of-year 必须在当年有效，否则会抛出异常。

      参数：
      year - 表示的年份，从 MIN_YEAR 到 MAX_YEAR
      dayOfYear - 要表示的日期，从 1 到 366
      返回：
      本地日期，不为空
      抛出：
      DateTimeException - 如果任何字段的值超出范围，或者年份中的日期对于年份无效

    • ofInstant

      public static LocalDate  ofInstant(Instant  instant, ZoneId  zone)
      从 Instant 和区域 ID 获取 LocalDate 的实例。

      这将根据指定的时刻创建一个本地日期。首先，使用区域 ID 和时刻获得与 UTC/格林威治的偏移量，这很简单，因为每个时刻只有一个有效偏移量。然后，即时和偏移量用于计算本地日期。

      参数：
      instant - 创建日期的时刻，不为空
      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 - 要转换的时间对象，不为空
      返回：
      本地日期，不为空
      抛出：
      DateTimeException - 如果无法转换为 LocalDate
      参见：

    • parse

      public static LocalDate  parse(CharSequence  text)
      从 2007-12-03 等文本字符串中获取 LocalDate 的实例。

      该字符串必须表示有效日期并使用 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 ，则通过调用 TemporalField.isSupportedBy(TemporalAccessor) 传递 this 作为参数来获得此方法的结果。字段是否支持由字段决定。

      指定者：
      isSupported 在接口 ChronoLocalDate 中
      指定者：
      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 作为参数来获得此方法的结果。是否支持该单元由单元决定。

      指定者：
      isSupported 在接口 ChronoLocalDate 中
      指定者：
      isSupported 在接口 Temporal 中
      参数：
      unit - 要检查的单位，null 返回 false
      返回：
      如果可以添加/减去单位，则为 true，否则为 false

    • range

      public ValueRange  range(TemporalField  field)
      获取指定字段的有效值范围。

      范围对象表示字段的最小和最大有效值。该日期用于提高返回范围的准确性。如果由于不支持该字段或其他原因而无法返回范围，则会抛出异常。

      如果该字段是一个ChronoField 那么查询就在这里实现。 supported fields 将返回适当的范围实例。所有其他 ChronoField 实例将抛出 UnsupportedTemporalTypeException 。

      如果该字段不是 ChronoField ，则通过调用 TemporalField.rangeRefinedBy(TemporalAccessor) 传递 this 作为参数来获得此方法的结果。能否获取范围由字段决定。

      指定者：
      range 在接口 TemporalAccessor 中
      参数：
      field - 查询范围的字段，不为空
      返回：
      该字段的有效值范围，不为空
      抛出：
      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 作为参数来获得此方法的结果。能否获取到该值，该值代表什么，由字段决定。

      指定者：
      get 在接口 TemporalAccessor 中
      参数：
      field - 要获取的字段，不为空
      返回：
      该字段的值
      抛出：
      DateTimeException - 如果无法获取该字段的值或该值超出该字段的有效值范围
      UnsupportedTemporalTypeException - 如果不支持该字段或值的范围超过 int
      ArithmeticException - 如果发生数字溢出

    • getLong

      public long getLong(TemporalField  field)
      从此日期获取指定字段的值作为 long 。

      这将查询此日期以获取指定字段的值。如果由于不支持该字段或其他原因而无法返回该值，则会抛出异常。

      如果该字段是一个ChronoField 那么查询就在这里实现。 supported fields 将根据此日期返回有效值。所有其他 ChronoField 实例将抛出 UnsupportedTemporalTypeException 。

      如果该字段不是 ChronoField ，则通过调用 TemporalField.getFrom(TemporalAccessor) 传递 this 作为参数来获得此方法的结果。能否获取到该值，该值代表什么，由字段决定。

      指定者：
      getLong 在接口 TemporalAccessor 中
      参数：
      field - 要获取的字段，不为空
      返回：
      该字段的值
      抛出：
      DateTimeException - 如果无法获得该字段的值
      UnsupportedTemporalTypeException - 如果不支持该字段
      ArithmeticException - 如果发生数字溢出

    • getChronology

      public IsoChronology  getChronology()
      获取此日期的年表，即 ISO 日历系统。

      Chronology 表示正在使用的日历系统。 ISO-8601 日历系统是当今世界大部分地区使用的现代民用日历系统。它相当于公历系统，在所有时间都适用今天的闰年规则。

      指定者：
      getChronology 在接口 ChronoLocalDate 中
      返回：
      ISO 年表，不为空

    • getEra

      public IsoEra  getEra()
      获取适用于该日期的纪元。

      官方 ISO-8601 标准没有定义纪元，但是 IsoChronology 定义了纪元。它定义了两个时代，从第一年开始的“CE”和从零年开始的“BCE”。由于 Julian-Gregorian 转换之前的日期与历史不符，因此“BCE”和“CE”之间的转换也不符合常用纪元，通常使用“BC”和“AD”。

      此类的用户通常应忽略此方法，因为它的存在主要是为了履行需要支持日本日历系统的 ChronoLocalDate 合同。

      指定者：
      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

      public Month  getMonth()
      使用 Month 枚举获取月份字段。

      此方法返回月份的枚举 Month 。这避免混淆 int 值的含义。如果您需要访问原始 int 值，则枚举会提供 int value 。

      返回：
      月份，不为空
      参见：

    • 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 proleptic 日历系统规则，检查年份是否为闰年。

      此方法在整个时间线上应用当前的闰年规则。一般来说，如果年份可以被四整除而没有余数，则为闰年。但是，能被 100 整除的年份不是闰年，但能被 400 整除的年份除外。

      例如，1904 是闰年，它可以被 4 整除。1900 不是闰年，因为它可以被 100 整除，但是 2000 是闰年，因为它可以被 400 整除。

      计算是有前瞻性的——将相同的规则应用到遥远的未来和遥远的过去。这在历史上是不准确的，但对于 ISO-8601 标准是正确的。

      指定者：
      isLeapYear 在接口 ChronoLocalDate 中
      返回：
      如果年份是闰年则为 true，否则为 false

    • lengthOfMonth

      public int lengthOfMonth()
      返回此日期表示的月份的长度。

      这将以天为单位返回月份的长度。例如，一月的日期将返回 31。

      指定者：
      lengthOfMonth 在接口 ChronoLocalDate 中
      返回：
      以天为单位的月份长度

    • lengthOfYear

      public int lengthOfYear()
      返回此日期表示的年份的长度。

      这将返回以天为单位的年份长度，365 或 366。

      指定者：
      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 作为参数传递来获得的。

      此实例是不可变的，不受此方法调用的影响。

      指定者：
      with 在接口 ChronoLocalDate 中
      指定者：
      with 在接口 Temporal 中
      参数：
      adjuster - 要使用的调节器，不为空
      返回：
      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 - 返回具有指定预期月份的 LocalDate。日期将保持不变，除非它对新的月份和年份无效。在这种情况下，日期将调整为新月份和年份的最大有效值。
      • YEAR_OF_ERA - 返回具有指定年份的 LocalDate。时代和月份将保持不变。日期也将保持不变，除非它对新的月份和年份无效。在这种情况下，日期将调整为新月份和年份的最大有效值。
      • YEAR - 返回具有指定年份的 LocalDate。月份将保持不变。日期也将保持不变，除非它对新的月份和年份无效。在这种情况下，日期将调整为新月份和年份的最大有效值。
      • ERA - 返回具有指定纪元的 LocalDate。年代和月份将保持不变。日期也将保持不变，除非它对新的月份和年份无效。在这种情况下，日期将调整为新月份和年份的最大有效值。

      在所有情况下，如果新值超出该字段的有效值范围，则会抛出 DateTimeException。

      所有其他 ChronoField 实例将抛出 UnsupportedTemporalTypeException 。

      如果该字段不是 ChronoField ，则通过调用 TemporalField.adjustInto(Temporal, long) 传递 this 作为参数来获得此方法的结果。在这种情况下，该字段决定是否以及如何调整瞬间。

      此实例是不可变的，不受此方法调用的影响。

      指定者：
      with 在接口 ChronoLocalDate 中
      指定者：
      with 在接口 Temporal 中
      参数：
      field - 要在结果中设置的字段，不为空
      newValue - 结果中字段的新值
      返回：
      基于 this 的 LocalDate 具有指定的字段集，不为空
      抛出：
      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（一月）到 12（十二月）
      返回：
      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) 将计算委托给金额对象。金额实现可以自由地以任何它希望的方式实现加法，但是它通常会回调 plus(long, TemporalUnit) 。查阅amount实现的文档，判断是否可以添加成功。

      此实例是不可变的，不受此方法调用的影响。

      指定者：
      plus 在接口 ChronoLocalDate 中
      指定者：
      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 添加了指定的十进制数。这相当于用金额乘以 10 调用 plusYears(long) 。日期将保持不变，除非它对新的月份和年份无效。在这种情况下，日期将调整为新月份和年份的最大有效值。
      • CENTURIES - 返回添加了指定世纪数的 LocalDate。这相当于用金额乘以 100 调用 plusYears(long) 。日期将保持不变，除非它对新的月份和年份无效。在这种情况下，日期将调整为新月份和年份的最大有效值。
      • MILLENNIA - 返回一个 LocalDate 添加了指定的千年数。这相当于用金额乘以 1,000 调用 plusYears(long) 。日期将保持不变，除非它对新的月份和年份无效。在这种情况下，日期将调整为新月份和年份的最大有效值。
      • ERAS - 返回添加了指定纪元数的 LocalDate。仅支持两个纪元，因此数量必须为一、零或负一。如果金额不为零，则年份会发生变化，因此时代年份不变。日期将保持不变，除非它对新的月份和年份无效。在这种情况下，日期将调整为新月份和年份的最大有效值。

      所有其他 ChronoUnit 实例将抛出 UnsupportedTemporalTypeException 。

      如果该字段不是 ChronoUnit ，则通过调用 TemporalUnit.addTo(Temporal, long) 传递 this 作为参数来获得此方法的结果。在这种情况下，该单元确定是否以及如何执行加法。

      此实例是不可变的，不受此方法调用的影响。

      指定者：
      plus 在接口 ChronoLocalDate 中
      指定者：
      plus 在接口 Temporal 中
      参数：
      amountToAdd - 添加到结果的单位数量，可能为负数
      unit - 添加量的单位，不为空
      返回：
      a 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 加上一天将得到 2009-01-01。

      此实例是不可变的，不受此方法调用的影响。

      参数：
      daysToAdd - 添加的天数，可能是负数
      返回：
      LocalDate 基于此日期加上天数，不为空
      抛出：
      DateTimeException - 如果结果超出支持的日期范围

    • minus

      public LocalDate  minus(TemporalAmount  amountToSubtract)
      返回此日期的副本，并减去指定的金额。

      这将返回一个 LocalDate ，基于这个，减去指定的数量。数量通常是 Period 但可以是实现 TemporalAmount 接口的任何其他类型。

      通过调用 TemporalAmount.subtractFrom(Temporal) 将计算委托给金额对象。金额实现可以自由地以任何它希望的方式实现减法，但是它通常会回调 minus(long, TemporalUnit) 。查阅 amount 实现的文档以确定是否可以成功减去。

      此实例是不可变的，不受此方法调用的影响。

      指定者：
      minus 在接口 ChronoLocalDate 中
      指定者：
      minus 在接口 Temporal 中
      参数：
      amountToSubtract - 要减去的金额，不为空
      返回：
      a LocalDate 基于此日期减去，不为空
      抛出：
      DateTimeException - 如果无法进行减法
      ArithmeticException - 如果发生数字溢出

    • minus

      public LocalDate  minus(long amountToSubtract, TemporalUnit  unit)
      返回此日期的副本，并减去指定的金额。

      这将返回一个 LocalDate ，基于这个，减去单位数量。如果无法减去金额，因为不支持该单位或出于其他原因，则会抛出异常。

      此方法等同于 plus(long, TemporalUnit) 取反金额。有关加法和减法如何工作的完整描述，请参阅该方法。

      此实例是不可变的，不受此方法调用的影响。

      指定者：
      minus 在接口 ChronoLocalDate 中
      指定者：
      minus 在接口 Temporal 中
      参数：
      amountToSubtract - 要从结果中减去的单位数量，可能为负数
      unit - 要减去的金额的单位，不为空
      返回：
      a 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 的副本，并减去指定的天数。

      此方法从天字段中减去指定的金额，并根据需要递减月份和年份字段，以确保结果保持有效。仅当超过最大/最小年份时，结果才无效。

      例如，2009-01-01 减去一天将得到 2008-12-31。

      此实例是不可变的，不受此方法调用的影响。

      参数：
      daysToSubtract - 要减去的天数，可能为负数
      返回：
      LocalDate 基于此日期减去天数，不为空
      抛出：
      DateTimeException - 如果结果超出支持的日期范围

    • query

      public <R> R query(TemporalQuery <R> query)
      使用指定查询查询此日期。

      这使用指定的查询策略对象查询此日期。 TemporalQuery 对象定义了用于获取结果的逻辑。阅读查询文档以了解此方法的结果。

      此方法的结果是通过对指定查询调用 TemporalQuery.queryFrom(TemporalAccessor) 方法并将 this 作为参数传递来获得的。

      指定者：
      query 在接口 ChronoLocalDate 中
      指定者：
      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);

      此实例是不可变的，不受此方法调用的影响。

      指定者：
      adjustInto 在接口 ChronoLocalDate 中
      指定者：
      adjustInto 在接口 TemporalAdjuster 中
      参数：
      temporal - 要调整的目标对象，不为空
      返回：
      调整后的对象，不为空
      抛出：
      DateTimeException - 如果无法进行调整
      ArithmeticException - 如果发生数字溢出

    • until

      public long until(Temporal  endExclusive, TemporalUnit  unit)
      根据指定的单位计算到另一个日期的时间量。

      这根据单个 TemporalUnit 计算两个 LocalDate 对象之间的时间量。起点和终点是this和指定的日期。如果结束早于开始，结果将为负。传递给此方法的 Temporal 使用 from(TemporalAccessor) 转换为 LocalDate。例如，可以使用 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 作为第一个参数并将转换后的输入时间作为第二个参数来获得此方法的结果。

      此实例是不可变的，不受此方法调用的影响。

      指定者：
      until 在接口 ChronoLocalDate 中
      指定者：
      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);
      应该根据哪个使代码更具可读性来做出选择。
      指定者：
      until 在接口 ChronoLocalDate 中
      参数：
      endDateExclusive - 结束日期，唯一的，可以按任何时间顺序排列，不为空
      返回：
      此日期和结束日期之间的时间段，不为空

    • datesUntil

      public Stream <LocalDate > datesUntil(LocalDate  endExclusive)
      返回按顺序排列的日期流。返回的流从该日期（含）开始，以 1 天的增量步长转到 endExclusive（不含）。

      此方法等效于 datesUntil(endExclusive, Period.ofDays(1)) 。

      参数：
      endExclusive - 结束日期，独占，不为空
      返回：
      LocalDate 值范围的顺序 Stream
      抛出：
      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。
      返回：
      LocalDate 值范围的顺序 Stream
      抛出：
      IllegalArgumentException - 如果步长为零，或者 step.getDays() 和 step.toTotalMonths() 符号相反，或者结束日期在此日期之前且步长为正，或者结束日期在此日期之后且步长为负
      自从：
      9

    • format

      public String  format(DateTimeFormatter  formatter)
      使用指定的格式化程序格式化此日期。

      该日期将传递给格式化程序以生成一个字符串。

      指定者：
      format 在接口 ChronoLocalDate 中
      参数：
      formatter - 要使用的格式化程序，不为空
      返回：
      格式化的日期字符串，不为空
      抛出：
      DateTimeException - 如果在打印过程中发生错误

    • atTime

      public LocalDateTime  atTime(LocalTime  time)
      将此日期与时间结合起来创建一个 LocalDateTime 。

      这将返回从该日期在指定时间形成的 LocalDateTime。日期和时间的所有可能组合均有效。

      指定者：
      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 到 999,999,999
      返回：
      从此日期和指定时间形成的本地日期时间，不为空
      抛出：
      DateTimeException - 如果任何字段的值超出范围

    • atTime

      public OffsetDateTime  atTime(OffsetTime  time)
      将此日期与偏移时间组合以创建 OffsetDateTime 。

      这将返回从该日期在指定时间形成的 OffsetDateTime。日期和时间的所有可能组合均有效。

      参数：
      time - 结合的时间，不为空
      返回：
      从此日期和指定时间形成的偏移日期时间，不为空

    • atStartOfDay

      public LocalDateTime  atStartOfDay()
      将此日期与午夜时间相结合，在该日期的开始创建一个 LocalDateTime。

      这将返回一个 LocalDateTime，从该日期开始的午夜 00:00 开始。

      返回：
      此日期开始时午夜的本地日期时间，不为空

    • 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) 。

      指定者：
      compareTo 在接口 ChronoLocalDate 中
      指定者：
      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() 中的方法相同。

      指定者：
      isAfter 在接口 ChronoLocalDate 中
      参数：
      other - 要比较的其他日期，不为空
      返回：
      如果此日期在指定日期之后，则为真

    • 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() 中的方法相同。

      指定者：
      isBefore 在接口 ChronoLocalDate 中
      参数：
      other - 要比较的其他日期，不为空
      返回：
      如果此日期早于指定日期，则为真

    • 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() 中的方法相同。

      指定者：
      isEqual 在接口 ChronoLocalDate 中
      参数：
      other - 要比较的其他日期，不为空
      返回：
      如果此日期等于指定日期，则为真

    • equals

      public boolean equals(Object  obj)
      检查此日期是否等于另一个日期。

      将此 LocalDate 与另一个进行比较，确保日期相同。

      只比较 LocalDate 类型的对象，其他类型返回 false。要比较两个 TemporalAccessor 实例的日期，包括两个不同年表中的日期，请使用 ChronoField.EPOCH_DAY 作为比较器。

      指定者：
      equals 在接口 ChronoLocalDate 中
      重写：
      equals 在类 Object 中
      参数：
      obj - 要检查的对象，null 返回 false
      返回：
      如果这等于另一个日期，则为真
      参见：

    • hashCode

      public int hashCode()
      此日期的哈希码。
      指定者：
      hashCode 在接口 ChronoLocalDate 中
      重写：
      hashCode 在类 Object 中
      返回：
      合适的哈希码
      参见：

    • toString

      public String  toString()
      将此日期输出为 String ，例如 2007-12-03 。

      输出将采用 ISO-8601 格式 uuuu-MM-dd 。

      指定者：
      toString 在接口 ChronoLocalDate 中
      重写：
      toString 在类 Object 中
      返回：
      此日期的字符串表示形式，不为空