模块 java.base

包 java.time.chrono

接口 ChronoLocalDate

所有父级接口：

Comparable<ChronoLocalDate> , Temporal , TemporalAccessor , TemporalAdjuster

所有已知的实现类：

HijrahDate , JapaneseDate , LocalDate , MinguoDate , ThaiBuddhistDate

public interface ChronoLocalDate extends Temporal , TemporalAdjuster , Comparable <ChronoLocalDate >
      

在任意时间顺序中没有时间或时区的日期，用于高级全球化用例。

大多数应用程序应将方法签名、字段和变量声明为 LocalDate ，而不是此接口。

ChronoLocalDate 是日期的抽象表示，其中 Chronology chronology 或日历系统是可插入的。日期根据 TemporalField 表示的字段定义，其中最常见的实现在 ChronoField 中定义。年表定义了日历系统的运作方式和标准字段的含义。

什么时候使用这个接口

API 的设计鼓励使用LocalDate 而不是这个接口，即使在应用程序需要处理多个日历系统的情况下也是如此。

这个概念乍一看似乎令人惊讶，因为全球化应用程序的自然方式最初可能看起来是抽象日历系统。然而，正如下面所探讨的，抽象日历系统通常是错误的方法，会导致逻辑错误并且很难发现错误。因此，选择使用此接口而不是 LocalDate 应该被视为应用程序范围的架构决策。

要考虑的架构问题

这些是在整个应用程序中使用此接口之前必须考虑的一些要点。

1) 使用此接口的应用程序，与仅使用 LocalDate 相比，出现错误的可能性要高得多。这是因为在开发时不知道正在使用的日历系统。错误的一个主要原因是开发人员将他们对 ISO 日历系统的日常知识的假设应用于旨在处理任何任意日历系统的代码。下面的部分概述了这些假设如何导致问题。减少这种增加的错误风险的主要机制是强大的代码审查过程。这也应该被视为代码生命周期维护的额外成本。

2) 该接口不强制实现的不变性。虽然实现说明表明所有实现都必须是不可变的，但代码或类型系统中没有任何内容可以强制执行此操作。因此，任何声明接受 ChronoLocalDate 的方法都可能被传递给编写不当或恶意编写的可变实现。

3）使用该接口的应用程序必须考虑时代的影响。 LocalDate 通过确保 getYear() 返回预测年份来保护用户免受时代概念的影响。该决定确保开发人员可以将 LocalDate 实例视为由三个字段组成 - 年、月和月。相比之下，此界面的用户必须将日期视为由四个字段组成 - 纪元、纪元年、年月和月日。额外的时代字段经常被遗忘，但它对于任意日历系统中的日期至关重要。例如，在日本历法系统中，纪元代表天皇的统治时期。每当一个统治结束而另一个统治开始时，纪年将重置为一年。

4) 在两个系统之间传递日期的唯一公认的国际标准是 ISO-8601 标准，它需要 ISO 日历系统。在整个应用程序中使用此接口将不可避免地导致需要跨网络或组件边界传递日期，从而需要特定于应用程序的协议或格式。

5) 长期持久性，例如数据库，几乎总是只接受 ISO-8601 日历系统（或相关的 Julian-Gregorian）中的日期。在其他日历系统中传递日期会增加与持久性交互的复杂性。

6) 大多数时候，在整个应用程序中传递 ChronoLocalDate 是不必要的，如下文最后一节所述。

导致多日历系统代码错误的错误假设

如上所述，在任意日历系统中尝试使用和操作日期时需要考虑许多问题。这些是一些关键问题。

查询日期并假定该值永远不会超过 31 的代码是无效的。一些日历系统在某些月份有超过 31 天。

向日期添加 12 个月并假定已添加一年的代码无效。一些日历系统有不同的月数，例如科普特或埃塞俄比亚的 13。

将日期加一个月并假定年中月份值将增加一个或换行到下一年的代码是无效的。一些日历系统一年中的月份数是可变的，例如希伯来语。

添加 1 个月，然后添加第二个 1 个月并假定日期将保持接近其原始值的代码是无效的。一些日历系统在最长月份的长度和最短月份的长度之间存在很大差异。例如，科普特语或埃塞俄比亚语有 12 个月 30 天和 1 个月 5 天。

添加 7 天并假定已添加一周的代码无效。一些日历系统有星期而不是七天，例如法国大革命。

假设因为 date1 的年份大于 date2 的年份，所以 date1 在 date2 之后的代码无效。当提到纪元时，这对所有日历系统都是无效的，尤其是日本历法系统，纪元在每个新天皇统治时重新开始。

将第一个月和第一天视为一年开始的代码无效。并非所有日历系统都在月份值为 1 时开始年份。

通常，在开发时日历系统未知时，操作日期甚至查询日期都容易出现错误。这就是为什么使用此接口的代码必须接受额外的代码审查的原因。这也是为什么避免这种接口类型的架构决策通常是正确的。

改为使用 LocalDate

在整个应用程序中使用此接口的主要替代方法如下。

• 根据 LocalDate 声明所有引用日期的方法签名。
• 要么将年表（日历系统）存储在用户配置文件中，要么从用户区域设置中查找年表
• 在打印和解析期间将 ISO LocalDate 与用户首选的日历系统相互转换

这种方法将全球化日历系统的问题视为本地化问题，并将其限制在 UI 层。这种方法与 java 平台中的其他本地化问题保持一致。

如上所述，在日历系统规则可插入的日期执行计算需要技巧，因此不推荐。幸运的是，很少需要在任意日历系统中对日期执行计算。例如，图书馆图书租赁计划的业务规则不太可能允许租赁一个月，其中月份的含义取决于用户的首选日历系统。

在任意日历系统中计算日期的一个关键用例是生成用于显示和用户交互的逐月日历。同样，这是一个 UI 问题，仅在 UI 层的几个方法中使用此接口可能是合理的。

在系统的任何其他部分，必须在 ISO 以外的日历系统中操作日期，用例通常会指定要使用的日历系统。例如，应用程序可能需要计算下一个伊斯兰或希伯来假期，这可能需要操纵日期。这种用例可以按如下方式处理：

• 从传递给方法的 ISO LocalDate 开始
• 将日期转换为备用日历系统，对于此用例，该系统是已知的而不是任意的
• 执行计算
• 转换回 LocalDate

编写低级框架或库的开发人员也应避免使用此接口。相反，应该使用两个通用访问接口之一。如果需要只读访问权限，请使用 TemporalAccessor ，如果需要读写访问权限，请使用 Temporal 。

实现要求：

必须小心实现此接口以确保其他类正确运行。所有可以实例化的实现都必须是最终的、不可变的和线程安全的。只要有可能，子类就应该是可序列化的。

额外的日历系统可以添加到系统中。有关详细信息，请参阅 Chronology 。

自从：

1.8

方法总结

修饰符和类型	方法	描述
default Temporal	adjustInto(Temporal temporal)	将指定的时间对象调整为与此对象具有相同的日期。
default ChronoLocalDateTime<?>	atTime(LocalTime localTime)	将此日期与时间结合起来创建一个 ChronoLocalDateTime 。
default int	compareTo(ChronoLocalDate other)	将此日期与另一个日期进行比较，包括年表。
boolean	equals(Object obj)	检查此日期是否等于另一个日期，包括年表。
default String	format(DateTimeFormatter formatter)	使用指定的格式化程序格式化此日期。
static ChronoLocalDate	from(TemporalAccessor temporal)	从时间对象中获取 ChronoLocalDate 的实例。
Chronology	getChronology()	获取此日期的年表。
default Era	getEra()	获取按年表定义的纪元。
int	hashCode()	此日期的哈希码。
default boolean	isAfter(ChronoLocalDate other)	检查此日期是否在忽略年表的指定日期之后。
default boolean	isBefore(ChronoLocalDate other)	检查此日期是否在忽略年表的指定日期之前。
default boolean	isEqual(ChronoLocalDate other)	检查此日期是否等于忽略年表的指定日期。
default boolean	isLeapYear()	检查年份是否为日历系统定义的闰年。
default boolean	isSupported(TemporalField field)	检查是否支持指定的字段。
default boolean	isSupported(TemporalUnit unit)	检查是否支持指定的单位。
int	lengthOfMonth()	返回此日期表示的月份的长度，如日历系统所定义。
default int	lengthOfYear()	返回此日期表示的年份长度，如日历系统所定义。
default ChronoLocalDate	minus(long amountToSubtract, TemporalUnit unit)	返回与此对象相同类型并减去指定句点的对象。
default ChronoLocalDate	minus(TemporalAmount amount)	返回与此对象相同类型的对象，但减去数量。
default ChronoLocalDate	plus(long amountToAdd, TemporalUnit unit)	返回与此对象相同类型的对象，并添加指定的时间段。
default ChronoLocalDate	plus(TemporalAmount amount)	返回与此对象相同类型的对象，并添加了数量。
default <R> R	query(TemporalQuery<R> query)	使用指定查询查询此日期。
static Comparator<ChronoLocalDate>	timeLineOrder()	获取一个比较器，该比较器按忽略年表的时间顺序比较 ChronoLocalDate。
default long	toEpochDay()	将此日期转换为纪元日。
String	toString()	将此日期输出为 String 。
ChronoPeriod	until(ChronoLocalDate endDateExclusive)	将此日期和另一个日期之间的时间段计算为 ChronoPeriod 。
long	until(Temporal endExclusive, TemporalUnit unit)	根据指定的单位计算到另一个日期的时间量。
default ChronoLocalDate	with(TemporalAdjuster adjuster)	返回与此对象具有相同类型并进行调整的调整对象。
default ChronoLocalDate	with(TemporalField field, long newValue)	返回与此对象相同类型的对象，但指定的字段已更改。

在接口 java.time.temporal.TemporalAccessor 中声明的方法

get, getLong, range

方法详情

timeLineOrder

static Comparator <ChronoLocalDate > timeLineOrder()
            

获取一个比较器，该比较器按忽略年表的时间顺序比较 ChronoLocalDate。

此比较器与 compareTo(java.time.chrono.ChronoLocalDate) 中的比较不同，因为它只比较基础日期而不是年表。这允许根据日期在本地时间线上的位置来比较不同日历系统中的日期。底层比较相当于比较epoch-day。

返回：

一个比较器，按时间顺序进行比较，忽略时间顺序

参见：

• isAfter(java.time.chrono.ChronoLocalDate)
• isBefore(java.time.chrono.ChronoLocalDate)
• isEqual(java.time.chrono.ChronoLocalDate)

from

static ChronoLocalDate  from(TemporalAccessor  temporal)
            

从时间对象中获取 ChronoLocalDate 的实例。

这将根据指定的时间获取本地日期。 TemporalAccessor 表示一组任意的日期和时间信息，该工厂将其转换为 ChronoLocalDate 的一个实例。

转换从时间对象中提取并组合年表和日期。该行为等效于将 Chronology.date(TemporalAccessor) 与提取的年表一起使用。允许实现执行优化，例如访问与相关对象等效的那些字段。

此方法与功能接口 TemporalQuery 的签名相匹配，允许它通过方法引用 ChronoLocalDate::from 用作查询。

参数：

temporal - 要转换的时间对象，不为空

返回：

日期，不为空

抛出：

DateTimeException - 如果无法转换为 ChronoLocalDate

参见：

• Chronology.date(TemporalAccessor)

getChronology

Chronology  getChronology()
            

获取此日期的年表。

Chronology 表示正在使用的日历系统。 ChronoField 中的时代和其他字段由年表定义。

返回：

年表，不为空

getEra

default Era  getEra()
            

获取按年表定义的纪元。

从概念上讲，时代是时间线的最大划分。大多数日历系统都有一个纪元，将时间线分为两个纪元。然而，有些有多个时代，例如每个领导人的统治时期。确切含义由 Chronology 确定。

所有正确实现的 Era 类都是单例，因此编写 date.getEra() == SomeChrono.ERA_NAME) 是有效的代码。

此默认实现使用 Chronology.eraOf(int) 。

返回：

适用于该日期的年代特定时代常量，不为空

isLeapYear

default boolean isLeapYear()
            

检查年份是否为日历系统定义的闰年。

闰年是比正常年长的一年。确切的含义由年表决定，其中闰年必须表示比非闰年长的年份长度。

此默认实现使用 Chronology.isLeapYear(long) 。

返回：

如果此日期是闰年，则为 true，否则为 false

lengthOfMonth

int lengthOfMonth()
            

返回此日期表示的月份的长度，如日历系统所定义。

这将以天为单位返回月份的长度。

返回：

以天为单位的月份长度

lengthOfYear

default int lengthOfYear()
            

返回此日期表示的年份长度，如日历系统所定义。

这将以天为单位返回一年的长度。

默认实现使用 isLeapYear() 并返回 365 或 366。

返回：

一年的天数

isSupported

default boolean isSupported(TemporalField  field)
            

检查是否支持指定的字段。

这将检查是否可以在该日期查询指定的字段。如果为 false，则调用 range 、get 和 with(TemporalField, long) 方法将抛出异常。

支持的字段集由年表定义，通常包括所有 ChronoField 日期字段。

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

指定者：

isSupported 在接口 TemporalAccessor 中

参数：

field - 要检查的字段，null 返回 false

返回：

如果该字段可以查询，则为 true，否则为 false

isSupported

default boolean isSupported(TemporalUnit  unit)
            

检查是否支持指定的单位。

这将检查指定的单位是否可以添加到该日期或从该日期中减去。如果为 false，则调用 plus(long, TemporalUnit) 和 minus 方法将抛出异常。

支持的单位集由年表定义，通常包括除 FOREVER 之外的所有 ChronoUnit 日期单位。

如果单位不是 ChronoUnit ，则通过调用 TemporalUnit.isSupportedBy(Temporal) 传递 this 作为参数来获得此方法的结果。是否支持该单元由单元决定。

指定者：

isSupported 在接口 Temporal 中

参数：

unit - 要检查的单位，null 返回 false

返回：

如果可以添加/减去单位，则为 true，否则为 false

with

default ChronoLocalDate  with(TemporalAdjuster  adjuster)
            

返回与此对象具有相同类型并进行调整的调整对象。

这会根据指定调整器的规则调整此日期时间。一个简单的调整器可能只是设置其中一个字段，例如年份字段。更复杂的调节器可能会将日期设置为该月的最后一天。 TemporalAdjusters 中提供了一系列常用调整。其中包括查找“本月的最后一天”和“下周三”。调节器负责处理特殊情况，例如不同长度的月份和闰年。

一些示例代码指示如何以及为什么使用此方法：

 date = date.with(Month.JULY);    // most key classes implement TemporalAdjuster
 date = date.with(lastDayOfMonth()); // static import from Adjusters
 date = date.with(next(WEDNESDAY));  // static import from Adjusters and DayOfWeek
 

指定者：

with 在接口 Temporal 中

参数：

adjuster - 要使用的调节器，不为空

返回：

进行了指定调整的同一类型的对象，不为空

抛出：

DateTimeException - 如果无法进行调整

ArithmeticException - 如果发生数字溢出

with

default ChronoLocalDate  with(TemporalField  field, long newValue)
            

返回与此对象相同类型的对象，但指定的字段已更改。

这将返回一个基于此对象的新对象，其中指定字段的值已更改。例如，在 LocalDate 上，这可用于设置年、月或月中的某天。返回的对象将具有与该对象相同的可观察类型。

在某些情况下，更改字段未完全定义。例如，如果目标对象是表示 1 月 31 日的日期，那么将月份更改为 2 月将不清楚。在这种情况下，字段负责解析结果。通常它会选择之前的有效日期，在本例中为 2 月的最后一个有效日期。

指定者：

with 在接口 Temporal 中

参数：

field - 要在结果中设置的字段，不为空

newValue - 结果中字段的新值

返回：

具有指定字段集的相同类型的对象，不为空

抛出：

DateTimeException - 如果无法设置该字段

UnsupportedTemporalTypeException - 如果不支持该字段

ArithmeticException - 如果发生数字溢出

plus

default ChronoLocalDate  plus(TemporalAmount  amount)
            

返回与此对象相同类型的对象，并添加了数量。

这会调整此时间，根据指定数量的规则添加。数量通常是 Period 但可以是实现 TemporalAmount 接口的任何其他类型，例如 Duration 。

一些示例代码指示如何以及为什么使用此方法：

 date = date.plus(period);        // add a Period instance
 date = date.plus(duration);       // add a Duration instance
 date = date.plus(workingDays(6));    // example user-written workingDays method
 

请注意，调用 plus 后跟 minus 不能保证返回相同的日期时间。

指定者：

plus 在接口 Temporal 中

参数：

amount - 要添加的数量，不为空

返回：

进行了指定调整的同一类型的对象，不为空

抛出：

DateTimeException - 如果无法添加

ArithmeticException - 如果发生数字溢出

plus

default ChronoLocalDate  plus(long amountToAdd, TemporalUnit  unit)
            

返回与此对象相同类型的对象，并添加指定的时间段。

此方法返回一个基于此对象的新对象，并添加了指定的时间段。例如，在 LocalDate 上，这可用于添加年数、月数或天数。返回的对象将具有与该对象相同的可观察类型。

在某些情况下，更改字段未完全定义。例如，如果目标对象是表示 1 月 31 日的日期，那么添加一个月就不清楚了。在这种情况下，字段负责解析结果。通常它会选择之前的有效日期，在本例中为 2 月的最后一个有效日期。

指定者：

plus 在接口 Temporal 中

参数：

amountToAdd - 要添加的指定单位的数量，可能是负数

unit - 添加量的单位，不为空

返回：

添加了指定时间段的相同类型的对象，不为空

抛出：

DateTimeException - 如果无法添加单位

ArithmeticException - 如果发生数字溢出

minus

default ChronoLocalDate  minus(TemporalAmount  amount)
            

返回与此对象相同类型的对象，但减去数量。

这会调整此时间，根据指定数量的规则减去。数量通常是 Period 但可以是实现 TemporalAmount 接口的任何其他类型，例如 Duration 。

一些示例代码指示如何以及为什么使用此方法：

 date = date.minus(period);        // subtract a Period instance
 date = date.minus(duration);       // subtract a Duration instance
 date = date.minus(workingDays(6));    // example user-written workingDays method
 

请注意，调用 plus 后跟 minus 不能保证返回相同的日期时间。

指定者：

minus 在接口 Temporal 中

参数：

amount - 要减去的金额，不为空

返回：

进行了指定调整的同一类型的对象，不为空

抛出：

DateTimeException - 如果无法进行减法

ArithmeticException - 如果发生数字溢出

minus

default ChronoLocalDate  minus(long amountToSubtract, TemporalUnit  unit)
            

返回与此对象相同类型并减去指定句点的对象。

此方法返回一个基于此对象并减去指定时间段的新对象。例如，在 LocalDate 上，这可用于减去若干年、月或日。返回的对象将具有与该对象相同的可观察类型。

在某些情况下，更改字段未完全定义。例如，如果目标对象是表示 3 月 31 日的日期，那么减去一个月就不清楚了。在这种情况下，字段负责解析结果。通常它会选择之前的有效日期，在本例中为 2 月的最后一个有效日期。

指定者：

minus 在接口 Temporal 中

参数：

amountToSubtract - 要减去的指定单位的数量，可能是负数

unit - 要减去的金额的单位，不为空

返回：

减去指定期间的相同类型的对象，不为空

抛出：

DateTimeException - 如果无法减去单位

UnsupportedTemporalTypeException - 如果不支持该单元

ArithmeticException - 如果发生数字溢出

query

default <R> R query(TemporalQuery <R> query)
            

使用指定查询查询此日期。

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

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

指定者：

query 在接口 TemporalAccessor 中

类型参数：

R - 结果的类型

参数：

query - 要调用的查询，不为空

返回：

查询结果，可能返回null（由查询定义）

抛出：

DateTimeException - 如果无法查询（由查询定义）

ArithmeticException - 如果发生数字溢出（由查询定义）

adjustInto

default 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 在接口 TemporalAdjuster 中

参数：

temporal - 要调整的目标对象，不为空

返回：

调整后的对象，不为空

抛出：

DateTimeException - 如果无法进行调整

ArithmeticException - 如果发生数字溢出

until

long until(Temporal  endExclusive, TemporalUnit  unit)
            

根据指定的单位计算到另一个日期的时间量。

这根据单个 TemporalUnit 计算两个 ChronoLocalDate 对象之间的时间量。起点和终点是this和指定的日期。如果结束早于开始，结果将为负。传递给此方法的 Temporal 使用 Chronology.date(TemporalAccessor) 转换为 ChronoLocalDate。计算返回一个整数，表示两个日期之间的完整单位数。例如，可以使用 startDate.until(endDate, DAYS) 计算两个日期之间的天数。

有两种等效的方法可以使用此方法。第一个是调用这个方法。第二种是使用 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 在接口 Temporal 中

参数：

endExclusive - 结束日期，独占，在相同的时间顺序中转换为 ChronoLocalDate，不为空

unit - 衡量数量的单位，不为空

返回：

此日期与结束日期之间的时间量

抛出：

DateTimeException - 如果无法计算金额，或者结束时间无法转换为 ChronoLocalDate

UnsupportedTemporalTypeException - 如果不支持该单元

ArithmeticException - 如果发生数字溢出

until

ChronoPeriod  until(ChronoLocalDate  endDateExclusive)
            

将此日期和另一个日期之间的时间段计算为 ChronoPeriod 。

这将计算两个日期之间的时间段。所有提供的年表都使用年、月和日计算周期，但是 ChronoPeriod API 允许使用其他单位表示周期。

起点和终点是this和指定的日期。如果结束早于开始，结果将为负。年、月、日的负号相同。

使用该日期的年表进行计算。如有必要，输入的日期将被转换以匹配。

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

参数：

endDateExclusive - 结束日期，唯一的，可以按任何时间顺序排列，不为空

返回：

此日期和结束日期之间的时间段，不为空

抛出：

DateTimeException - 如果无法计算周期

ArithmeticException - 如果发生数字溢出

format

default String  format(DateTimeFormatter  formatter)
            

使用指定的格式化程序格式化此日期。

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

默认实现的行为必须如下所示：

 return formatter.format(this);
 

参数：

formatter - 要使用的格式化程序，不为空

返回：

格式化的日期字符串，不为空

抛出：

DateTimeException - 如果在打印过程中发生错误

atTime

default ChronoLocalDateTime <?> atTime(LocalTime  localTime)
            

将此日期与时间结合起来创建一个 ChronoLocalDateTime 。

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

参数：

localTime - 使用的本地时间，不为空

返回：

从此日期和指定时间形成的本地日期时间，不为空

toEpochDay

default long toEpochDay()
            

将此日期转换为纪元日。

Epoch Day count 是一个简单的递增天数，其中第 0 天是 1970-01-01 (ISO)。此定义对于所有年表都是相同的，从而可以进行转换。

此默认实现查询 EPOCH_DAY 字段。

返回：

相当于这个日期的纪元日

compareTo

default int compareTo(ChronoLocalDate  other)
            

将此日期与另一个日期进行比较，包括年表。

比较首先基于基础时间线日期，然后基于年表。正如 Comparable 所定义的那样，它“与等于一致”。

例如，以下是比较器顺序：

1. 2012-12-03 (ISO)
2. 2012-12-04 (ISO)
3. 2555-12-04 (ThaiBuddhist)
4. 2012-12-05 (ISO)

值 #2 和 #3 表示时间线上的相同日期。当两个值表示相同的日期时，将比较时间顺序 ID 以区分它们。需要此步骤才能使排序“与等价一致”。

如果所有被比较的日期对象都在同一个年表中，则不需要额外的年表阶段，只使用本地日期。要比较两个 TemporalAccessor 实例的日期，包括两个不同年表中的日期，请使用 ChronoField.EPOCH_DAY 作为比较器。

此默认实现执行上面定义的比较。

指定者：

compareTo 在接口 Comparable<ChronoLocalDate> 中

参数：

other - 要比较的其他日期，不为空

返回：

比较值，小于则为负，大于则为正

isAfter

default boolean isAfter(ChronoLocalDate  other)
            

检查此日期是否在忽略年表的指定日期之后。

此方法与 compareTo(java.time.chrono.ChronoLocalDate) 中的比较不同，因为它只比较基础日期而不是年表。这允许根据时间线位置比较不同日历系统中的日期。这相当于使用 date1.toEpochDay() > date2.toEpochDay() 。

此默认实现基于纪元日执行比较。

参数：

other - 要比较的其他日期，不为空

返回：

如果这是在指定日期之后，则为真

isBefore

default boolean isBefore(ChronoLocalDate  other)
            

检查此日期是否在忽略年表的指定日期之前。

此方法与 compareTo(java.time.chrono.ChronoLocalDate) 中的比较不同，因为它只比较基础日期而不是年表。这允许根据时间线位置比较不同日历系统中的日期。这相当于使用 date1.toEpochDay() < date2.toEpochDay() 。

此默认实现基于纪元日执行比较。

参数：

other - 要比较的其他日期，不为空

返回：

如果这是在指定日期之前，则为真

isEqual

default boolean isEqual(ChronoLocalDate  other)
            

检查此日期是否等于忽略年表的指定日期。

此方法与 compareTo(java.time.chrono.ChronoLocalDate) 中的比较不同，因为它只比较基础日期而不是年表。这允许根据时间线位置比较不同日历系统中的日期。这相当于使用 date1.toEpochDay() == date2.toEpochDay() 。

此默认实现基于纪元日执行比较。

参数：

other - 要比较的其他日期，不为空

返回：

如果基础日期等于指定日期，则为真

equals

boolean equals(Object  obj)
            

检查此日期是否等于另一个日期，包括年表。

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

要比较两个 TemporalAccessor 实例的日期，包括两个不同年表中的日期，请使用 ChronoField.EPOCH_DAY 作为比较器。

重写：

equals 在类 Object 中

参数：

obj - 要检查的对象，null 返回 false

返回：

如果这等于另一个日期，则为真

参见：

• Object.hashCode()
• HashMap

hashCode

int hashCode()
            

此日期的哈希码。

重写：

hashCode 在类 Object 中

返回：

合适的哈希码

参见：

• Object.equals(java.lang.Object)
• System.identityHashCode(java.lang.Object)

toString

String  toString()
            

将此日期输出为 String 。

输出将包括完整的本地日期。

重写：

toString 在类 Object 中

返回：

格式化日期，不为空