Module java.base

Package java.time

Class 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方法不合适。

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

实现要求:

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

自从:

1.8

参见:

• Serialized Form

Field Summary

Fields

Modifier and Type	Field	Description
static final LocalDate	EPOCH	时代年份LocalDate，'1970-01-01'。
static final LocalDate	MAX	最大支持的LocalDate，'+999999999-12-31'。
static final LocalDate	MIN	最小支持的LocalDate，'-999999999-01-01'。

Method Summary

Modifier and Type	Method	Description
Temporal	adjustInto(Temporal temporal)	调整指定的时间对象，使其具有与此对象相同的日期。
LocalDateTime	atStartOfDay()	将这个日期与午夜时间组合，创建一个LocalDateTime在这个日期的开始。
ZonedDateTime	atStartOfDay(ZoneId zone)	根据时区规则，从这个日期返回一个最早有效时间的分区日期时间。
LocalDateTime	atTime(int hour, int minute)	将这个日期与时间组合，创建一个LocalDateTime。
LocalDateTime	atTime(int hour, int minute, int second)	将这个日期与时间组合，创建一个LocalDateTime。
LocalDateTime	atTime(int hour, int minute, int second, int nanoOfSecond)	将这个日期与时间组合，创建一个LocalDateTime。
LocalDateTime	atTime(LocalTime time)	将这个日期与时间组合，创建一个LocalDateTime。
OffsetDateTime	atTime(OffsetTime time)	将这个日期与偏移时间组合，创建一个OffsetDateTime。
int	compareTo(ChronoLocalDate other)	将这个日期与另一个日期进行比较。
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的副本。

Methods declared in class java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods declared in interface java.time.chrono.ChronoLocalDate

toEpochDay

Field Details

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

Method Details

now

             public static LocalDate now()
            

从默认时区的系统时钟获取当前日期。

这将查询默认时区中的系统时钟以获取当前日期。

使用这种方法将阻止使用替代时钟进行测试，因为时钟是硬编码的。

返回:

使用系统时钟和默认时区的当前日期，非空

now

             public static LocalDate now(ZoneId zone)
            

从指定时区的系统时钟获取当前日期。

这将查询系统时钟以获取当前日期。指定时区避免依赖默认时区。

使用这种方法将阻止使用替代时钟进行测试，因为时钟是硬编码的。

参数:

zone - 要使用的区域ID，非空

返回:

使用系统时钟获取当前日期，非空

now

             public static LocalDate now(Clock clock)
            

从指定时钟获取当前日期。

这将查询指定的时钟以获取当前日期-今天。使用这种方法允许使用替代时钟进行测试。可以使用依赖注入引入替代时钟。

参数:

clock - 要使用的时钟，非空

返回:

当前日期，非空

of

             public static LocalDate of(int year, Month month, int dayOfMonth)
            

从年、月和日获取 LocalDate 的实例。

返回一个具有指定年、月和日的 LocalDate。该日必须对该年和月有效，否则将抛出异常。

参数:

year - 要表示的年份，从 MIN_YEAR 到 MAX_YEAR

month - 要表示的年份，不为 null

dayOfMonth - 要表示的月份中的日期，从 1 到 31

返回:

本地日期，不为 null

抛出:

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

返回:

本地日期，不为 null

抛出:

DateTimeException - 如果任何字段的值超出范围，或者日期无效

ofYearDay

             public static LocalDate ofYearDay(int year, int dayOfYear)
            

从年和一年中的日期获取 LocalDate 的实例。

返回一个具有指定年和一年中的日期的 LocalDate。该一年中的日期必须对该年有效，否则将抛出异常。

参数:

year - 要表示的年份，从 MIN_YEAR 到 MAX_YEAR

dayOfYear - 要表示的一年中的日期，从 1 到 366

返回:

本地日期，不为 null

抛出:

DateTimeException - 如果任何字段的值超出范围，或者日期无效

ofInstant

             public static LocalDate ofInstant(Instant instant, ZoneId zone)
            

从 Instant 和区域 ID 获取 LocalDate 的实例。

基于指定的即时创建本地日期。首先，使用区域 ID 和即时获取与 UTC/Greenwich 的偏移量，这很简单，因为每个即时只有一个有效的偏移量。然后，使用即时和偏移量来计算本地日期。

参数:

instant - 要从中创建日期的即时，不为 null

zone - 时区，可以是偏移量，不为 null

返回:

本地日期，不为 null

抛出:

DateTimeException - 如果结果超出支持的范围

自 JDK 版本:

9

ofEpochDay

             public static LocalDate ofEpochDay(long epochDay)
            

从纪元日计数获取 LocalDate 的实例。

返回一个具有指定纪元日的 LocalDate。 EPOCH_DAY 是一个简单的递增天数计数，其中第 0 天是 1970-01-01。负数代表较早的日期。

参数:

epochDay - 要转换的纪元日，基于 1970-01-01 纪元

返回:

本地日期，不为 null

抛出:

DateTimeException - 如果纪元日超出支持的日期范围

from

             public static LocalDate from(TemporalAccessor temporal)
            

从时间对象获取 LocalDate 的实例。

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

转换使用 TemporalQueries.localDate() 查询，该查询依赖于提取 EPOCH_DAY 字段。

此方法与函数接口 TemporalQuery 的签名匹配，允许通过方法引用 LocalDate::from 使用作为查询。

参数:

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

返回:

本地日期，不为 null

抛出:

DateTimeException - 如果无法转换为 LocalDate

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)
            

检查是否支持指定字段。

检查此日期是否可以查询指定字段。如果为 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，则在此处实现查询。支持的字段将返回适当的范围实例。所有其他ChronoField实例将抛出UnsupportedTemporalTypeException。

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

指定者：

range 在接口 TemporalAccessor中

参数：

field - 要查询范围的字段，不能为空

返回：

字段的有效值范围，不能为空

抛出：

DateTimeException - 如果无法获取字段的范围

UnsupportedTemporalTypeException - 如果不支持该字段

get

             public int get(TemporalField field)
            

从此日期获取指定字段的值作为int。

查询此日期以获取指定字段的值。返回的值将始终在字段的有效值范围内。如果无法返回值，因为不支持该字段或出于其他原因，将抛出异常。

如果字段是一个ChronoField，则在此处实现查询。支持的字段将根据此日期返回有效值，除了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，则在此处实现查询。支持的字段将根据此日期返回有效值。所有其他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标准未定义纪元，但 定义了两个纪元，从公元一年开始的“CE”和从零年开始向后的“BCE”。由于儒略-格里高利历转换之前的日期与历史不符，因此“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。

此方法将月份作为从1到12的int返回。通过调用getMonth()使用枚举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标准是正确的。

指定者:

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。调整器负责处理特殊情况，例如月份的长度和闰年。

例如，以下代码返回七月的最后一天的日期：

  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 - 要使用的调整器，不能为空

返回:

基于this进行调整后的LocalDate，不能为空

抛出:

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，具有请求的年份，不为null

抛出:

DateTimeException - 如果年份值无效

withMonth

             public LocalDate withMonth(int month)
            

返回具有更改的年份的此LocalDate的副本。

如果对于该年份来说日期无效，则会更改为该月份的最后一个有效日期。

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

参数:

month - 要设置的月份，从1（一月）到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的副本。

如果结果日期无效，则会抛出异常。

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

参数:

dayOfYear - 要设置的年份中的日期，从1到365-366

返回:

基于此日期的LocalDate，具有请求的日期，不为null

抛出:

DateTimeException - 如果日期值无效，或者如果日期对于该年份无效

plus

             public LocalDate plus(TemporalAmount amountToAdd)
            

返回添加指定数量后的此日期的副本。

这将返回一个LocalDate，基于此日期，添加了指定的数量。该数量通常是Period，但也可以是实现TemporalAmount接口的任何其他类型。

通过调用TemporalAmount.addTo(Temporal)将计算委托给数量对象。数量的实现可以以任何希望的方式实现添加，但通常会回调到plus(long, TemporalUnit)。请查阅数量实现的文档，以确定是否可以成功添加。

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

指定者:

plus 在接口 ChronoLocalDate

指定者:

plus 在接口 Temporal

参数:

amountToAdd - 要添加的数量，不为null

返回:

基于此日期的LocalDate，进行了添加，不为null

抛出:

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。仅支持两个时代，因此数量必须为一、零或负一。如果数量非零，则更改年份，以使时代年份保持不变。日期将保持不变，除非对于新月份和年份而言无效。在这种情况下，日期将调整为新月份和年份的最大有效值。

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

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

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

指定者:

plus 在接口 ChronoLocalDate

指定者:

plus 在接口 Temporal

参数:

amountToAdd - 要添加到结果的单位数量，可以为负数

unit - 要添加的单位，不为null

返回:

基于此日期的LocalDate，添加了指定数量，不为null

抛出:

DateTimeException - 如果无法进行添加

UnsupportedTemporalTypeException - 如果单位不受支持

ArithmeticException - 如果发生数值溢出

plusYears

             public LocalDate plusYears(long yearsToAdd)
            

返回添加指定年数后的此LocalDate的副本。

此方法将在三个步骤中将指定的数量添加到年份字段中：

1. 将输入年份添加到年份字段
2. 检查结果日期是否无效
3. 如有必要，调整日期的日期为最后一个有效日期

例如，2008-02-29（闰年）加一年将导致无效日期2009-02-29（标准年）。而不是返回无效结果，选择了该月的最后一个有效日期，即2009-02-28。

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

参数:

yearsToAdd - 要添加的年数，可以为负数

返回:

基于此日期的LocalDate，添加了年数，不为null

抛出:

DateTimeException - 如果结果超出支持的日期范围

plusMonths

             public LocalDate plusMonths(long monthsToAdd)
            

返回添加指定月份数后的此LocalDate的副本。

此方法通过三个步骤将指定的数量添加到月份字段中：

1. 将输入的月份添加到年份字段
2. 检查结果日期是否无效
3. 如有必要，调整日期的天数为最后一个有效日期

例如，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)。请查阅数量实现的文档，以确定是否可以成功执行减法。

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

指定者：

minus 在接口 ChronoLocalDate

指定者：

minus 在接口 Temporal

参数：

amountToSubtract - 要减去的数量，不为null

返回：

基于此日期的LocalDate，已进行减法，不为null

抛出：

DateTimeException - 如果无法进行减法

ArithmeticException - 如果发生数值溢出

minus

             public LocalDate minus(long amountToSubtract, TemporalUnit unit)
            

返回减去指定数量后的此日期的副本。

返回一个LocalDate，基于此日期，减去单位的数量。如果无法减去数量，因为单位不受支持或出于其他原因，将抛出异常。

此方法等效于使用负数的plus(long, TemporalUnit)。查看该方法以获取有关加法（因此减法）工作原理的完整描述。

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

指定者：

minus 在接口 ChronoLocalDate

指定者：

minus 在接口 Temporal

参数：

amountToSubtract - 要从结果中减去的单位数量，可以为负数

unit - 要减去的数量的单位，不为null

返回：

基于此日期的LocalDate，已减去指定数量，不为null

抛出：

DateTimeException - 如果无法进行减法

UnsupportedTemporalTypeException - 如果单位不受支持

ArithmeticException - 如果发生数值溢出

minusYears

             public LocalDate minusYears(long yearsToSubtract)
            

返回减去指定年数后的此LocalDate的副本。

此方法通过三个步骤从年份字段中减去指定的数量：

1. 从年份字段中减去输入的年数
2. 检查结果日期是否无效
3. 如有必要，调整日期的天数为最后一个有效日期

例如，2008-02-29（闰年）减去一年将导致无效日期 2007-02-29（标准年）。而不是返回无效结果，选择该月的最后一个有效日期，即 2007-02-28。

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

参数：

yearsToSubtract - 要减去的年数，可以为负数

返回：

基于此日期的LocalDate，已减去年数，不为null

抛出：

DateTimeException - 如果结果超出支持的日期范围

minusMonths

             public LocalDate minusMonths(long monthsToSubtract)
            

返回减去指定月份数后的此LocalDate的副本。

此方法通过三个步骤从月份字段中减去指定的数量：

1. 从年份字段中减去输入的月份
2. 检查结果日期是否无效
3. 如有必要，调整日期的天数为最后一个有效日期

例如，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作为参数。

指定者：

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)来反转调用模式更清晰：

   // 这两行代码是等效的，但推荐使用第二种方法
   temporal = thisLocalDate.adjustInto(temporal);
   temporal = temporal.with(thisLocalDate);
 

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

指定者：

adjustInto 在接口 ChronoLocalDate中

指定者：

adjustInto 在接口 TemporalAdjuster中

参数：

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

返回：

调整后的对象，不能为空

抛出：

DateTimeException - 如果无法进行调整

ArithmeticException - 如果发生数值溢出

until

             public long until(Temporal endExclusive, TemporalUnit unit)
            

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

这计算两个LocalDate对象之间的时间量，以单个TemporalUnit为单位。起始点和结束点分别为this和指定的日期。如果结束在起始之前，则结果将为负数。传递给此方法的Temporal将使用from(TemporalAccessor)转换为LocalDate。例如，可以使用startDate.until(endDate, DAYS)来计算两个日期之间的天数。

计算返回一个整数，表示两个日期之间完整单位的数量。例如，2012-06-15和2012-08-14之间的月数只有一个月，因为相差不到两个月的一天。

有两种等效的使用方法。第一种是调用此方法。第二种是使用TemporalUnit.between(Temporal, Temporal)：

   // 这两行代码是等效的
   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)：

   // 这两行代码是等效的
   period = start.until(end);
   period = Period.between(start, end);
 

应根据哪种方法使代码更易读来选择。

指定者：

until 在接口 ChronoLocalDate中

参数：

endDateExclusive - 结束日期（不包括），可以是任何年表，不能为空

返回：

此日期与结束日期之间的期间，不能为空

datesUntil

             public Stream<LocalDate> datesUntil(LocalDate endExclusive)
            

返回一个按顺序排列的日期流。返回的流从此日期（包括）开始，到endExclusive（不包括）结束，步长为1天。

此方法等同于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)
            

将此日期与另一个日期进行比较。

比较主要基于日期，从最早到最晚。它是“与equals一致”的，如Comparable所定义。

如果所有被比较的日期都是LocalDate的实例，则比较将完全基于日期。如果要比较的一些日期在不同的年表中，则还会考虑年表，参见ChronoLocalDate.compareTo(java.time.chrono.ChronoLocalDate)。

指定者：

compareTo 在接口 ChronoLocalDate中

指定者：

compareTo 在接口 Comparable<ChronoLocalDate>中

参数：

other - 要比较的另一个日期，不能为空

返回：

比较器值，即此本地日期与other本地日期以及此年表与other年表的比较，按顺序返回第一个非零结果，否则返回零

参见：

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

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 - 要比较的另一个日期，不能为空

返回：

如果此日期在指定日期之后，则为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()的方法相同。

指定者：

isBefore 在接口 ChronoLocalDate中

参数：

other - 要比较的另一个日期，不能为空

返回：

如果此日期在指定日期之前，则为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()的方法相同。

指定者:

isEqual 在接口 ChronoLocalDate

参数:

other - 要比较的另一个日期，不能为空

返回值:

如果此日期等于指定日期，则为true

equals

             public boolean equals(Object obj)
            

检查此日期是否等于另一个日期。

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

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

指定者:

equals 在接口 ChronoLocalDate

覆盖:

equals 在类 Object

参数:

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

返回值:

如果此日期等于另一个日期，则为true

参见:

• Object.hashCode()
• HashMap

hashCode

             public int hashCode()
            

此日期的哈希码。

指定者:

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。

指定者:

toString 在接口 ChronoLocalDate

覆盖:

toString 在类 Object

返回值:

此日期的字符串表示，不能为空