模块 java.base

包 java.time.temporal

枚举类枚举类 ChronoField

java.lang.Object

java.lang.Enum <ChronoField >

java.time.temporal.ChronoField

所有已实现的接口：

Serializable , Comparable<ChronoField> , Constable , TemporalField

public enum ChronoField extends Enum <ChronoField > implements TemporalField 
      

一组标准字段。

这组字段提供基于字段的访问来操作日期、时间或日期时间。可以通过实施 TemporalField 来扩展标准字段集。

这些字段旨在适用于多个日历系统。例如，大多数非 ISO 日历系统将日期定义为年月日，只是规则略有不同。每个字段的文档解释了它是如何运作的。

实现要求：

这是一个最终的、不可变的和线程安全的枚举。

自从：

1.8

内部类总结

在类 java.lang.Enum 中声明的嵌套类/接口

Enum.EnumDesc<E extends Enum<E>>

枚举常量总结

枚举常量

枚举常量	描述
ALIGNED_DAY_OF_WEEK_IN_MONTH	一个月内对齐的星期几。
ALIGNED_DAY_OF_WEEK_IN_YEAR	一年内对齐的星期几。
ALIGNED_WEEK_OF_MONTH	一个月内对齐的一周。
ALIGNED_WEEK_OF_YEAR	一年内对齐的一周。
AMPM_OF_DAY	上午下午。
CLOCK_HOUR_OF_AMPM	am-pm 的时钟时间。
CLOCK_HOUR_OF_DAY	一天中的时钟小时。
DAY_OF_MONTH	每月的第几天。
DAY_OF_WEEK	星期几，例如星期二。
DAY_OF_YEAR	一年中的某一天。
EPOCH_DAY	纪元日，基于 Java 纪元 1970-01-01 (ISO)。
ERA	时代。
HOUR_OF_AMPM	上午-下午的时间。
HOUR_OF_DAY	一天中的小时。
INSTANT_SECONDS	即时纪元秒。
MICRO_OF_DAY	微天。
MICRO_OF_SECOND	微秒。
MILLI_OF_DAY	毫日。
MILLI_OF_SECOND	毫秒。
MINUTE_OF_DAY	一天中的每一分钟。
MINUTE_OF_HOUR	整点。
MONTH_OF_YEAR	一年中的月份，例如三月。
NANO_OF_DAY	纳米时代。
NANO_OF_SECOND	纳秒级。
OFFSET_SECONDS	与 UTC/格林威治的偏移量。
PROLEPTIC_MONTH	基于预测月，从第 0 年开始按顺序计算月份。
SECOND_OF_DAY	第二天。
SECOND_OF_MINUTE	第二分钟。
YEAR	预产期，例如 2012 年。
YEAR_OF_ERA	纪元中的年份。

方法总结

修饰符和类型	方法	描述
<R extends Temporal> R	adjustInto(R temporal, long newValue)	返回具有此字段集值的指定时间对象的副本。
int	checkValidIntValue(long value)	检查指定的值是否有效并适合 int 。
long	checkValidValue(long value)	检查指定的值是否对此字段有效。
TemporalUnit	getBaseUnit()	获取字段的测量单位。
long	getFrom(TemporalAccessor temporal)	从指定的时间对象中获取此字段的值。
TemporalUnit	getRangeUnit()	获取字段绑定的范围。
boolean	isDateBased()	检查此字段是否表示日期的组成部分。
boolean	isSupportedBy(TemporalAccessor temporal)	检查时间对象是否支持此字段。
boolean	isTimeBased()	检查此字段是否表示时间的组成部分。
ValueRange	range()	获取字段的有效值范围。
ValueRange	rangeRefinedBy(TemporalAccessor temporal)	使用时间对象获取此字段的有效值范围以优化结果。
String	toString()	返回声明中包含的此枚举常量的名称。
static ChronoField	valueOf(String name)	返回具有指定名称的此类的枚举常量。
static ChronoField[]	values()	返回一个数组，其中包含此枚举类的常量，按照它们声明的顺序排列。

在类 java.lang.Enum 中声明的方法

clone, compareTo, describeConstable, equals, finalize, getDeclaringClass, hashCode, name, ordinal, toString, valueOf

在类 java.lang.Object 中声明的方法

getClass, notify, notifyAll, wait, wait, wait

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

getDisplayName, resolve

枚举常量详细信息

NANO_OF_SECOND

public static final ChronoField  NANO_OF_SECOND
            

纳秒级。

这计算秒内的纳秒，从 0 到 999,999,999。该字段对所有日历系统具有相同的含义。

该字段用于表示处理任何小数秒的纳秒级。如果 TemporalAccessor 的实现可以返回 SECOND_OF_MINUTE 、SECOND_OF_DAY 或 INSTANT_SECONDS 的值，则它们应该为该字段提供一个值，并用零填充未知精度。

当此字段用于设置值时，它应该设置与对象存储一样多的精度，使用整数除法去除多余的精度。例如，如果TemporalAccessor 将时间存储为毫秒精度，则在替换毫秒之前必须将纳秒除以 1,000,000。

解析此字段时，其行为等同于以下内容：该值在严格和智能模式下验证，但在宽松模式下不验证。该字段结合 MILLI_OF_SECOND 和 MICRO_OF_SECOND 进行解析。

NANO_OF_DAY

public static final ChronoField  NANO_OF_DAY
            

纳米时代。

这将计算一天中的纳秒，从 0 到 (24 * 60 * 60 * 1,000,000,000) - 1。该字段对于所有日历系统具有相同的含义。

该字段用于表示处理任何小数秒的纳日级。如果 TemporalAccessor 的实现可以为 SECOND_OF_DAY 返回一个用零填充未知精度的值，则它们应该为此字段提供一个值。

解析此字段时，其行为等同于以下内容：该值在严格和智能模式下验证，但在宽松模式下不验证。该值被拆分为 NANO_OF_SECOND、SECOND_OF_MINUTE、MINUTE_OF_HOUR 和 HOUR_OF_DAY 字段。

MICRO_OF_SECOND

public static final ChronoField  MICRO_OF_SECOND
            

微秒。

这计算秒内的微秒，从 0 到 999,999。该字段对所有日历系统具有相同的含义。

该字段用于表示处理任何小数秒的微秒。如果 TemporalAccessor 的实现可以返回 SECOND_OF_MINUTE 、SECOND_OF_DAY 或 INSTANT_SECONDS 的值，则它们应该为该字段提供一个值，并用零填充未知精度。

当此字段用于设置值时，它的行为方式应与设置 NANO_OF_SECOND 的方式相同，即值乘以 1,000。

解析此字段时，其行为等同于以下内容：该值在严格和智能模式下验证，但在宽松模式下不验证。该字段与 MILLI_OF_SECOND 组合解析为 NANO_OF_SECOND 。

MICRO_OF_DAY

public static final ChronoField  MICRO_OF_DAY
            

微天。

这计算一天中的微秒，从 0 到 (24 * 60 * 60 * 1,000,000) - 1。此字段对所有日历系统具有相同的含义。

该字段用于表示处理任何小数秒的微日。如果 TemporalAccessor 的实现可以为 SECOND_OF_DAY 返回一个用零填充未知精度的值，则它们应该为此字段提供一个值。

当此字段用于设置值时，它的行为方式应与将值乘以 1,000 设置 NANO_OF_DAY 相同。

解析此字段时，其行为等同于以下内容：该值在严格和智能模式下验证，但在宽松模式下不验证。该值拆分为 MICRO_OF_SECOND、SECOND_OF_MINUTE、MINUTE_OF_HOUR 和 HOUR_OF_DAY 字段。

MILLI_OF_SECOND

public static final ChronoField  MILLI_OF_SECOND
            

毫秒。

这计算秒内的毫秒数，从 0 到 999。该字段对于所有日历系统具有相同的含义。

该字段用于表示处理任何小数秒的毫秒数。如果 TemporalAccessor 的实现可以返回 SECOND_OF_MINUTE 、SECOND_OF_DAY 或 INSTANT_SECONDS 的值，则它们应该为该字段提供一个值，并用零填充未知精度。

当此字段用于设置值时，它的行为方式应与将值乘以 1,000,000 设置 NANO_OF_SECOND 相同。

解析此字段时，其行为等同于以下内容：该值在严格和智能模式下验证，但在宽松模式下不验证。该字段与 MICRO_OF_SECOND 组合解析为 NANO_OF_SECOND 。

MILLI_OF_DAY

public static final ChronoField  MILLI_OF_DAY
            

毫日。

这将计算一天中的毫秒数，从 0 到 (24 * 60 * 60 * 1,000) - 1。该字段对于所有日历系统具有相同的含义。

该字段用于表示处理任意小数秒的毫秒数。如果 TemporalAccessor 的实现可以为 SECOND_OF_DAY 返回一个用零填充未知精度的值，则它们应该为此字段提供一个值。

当此字段用于设置值时，它的行为方式应与将值乘以 1,000,000 后设置 NANO_OF_DAY 的方式相同。

解析此字段时，其行为等同于以下内容：该值在严格和智能模式下验证，但在宽松模式下不验证。该值被拆分为 MILLI_OF_SECOND、SECOND_OF_MINUTE、MINUTE_OF_HOUR 和 HOUR_OF_DAY 字段。

SECOND_OF_MINUTE

public static final ChronoField  SECOND_OF_MINUTE
            

第二分钟。

这计算分钟内的秒数，从 0 到 59。该字段对所有日历系统具有相同的含义。

解析此字段时，其行为等同于以下内容：该值在严格和智能模式下验证，但在宽松模式下不验证。

SECOND_OF_DAY

public static final ChronoField  SECOND_OF_DAY
            

第二天。

这计算一天中的秒数，从 0 到 (24 * 60 * 60) - 1。该字段对于所有日历系统具有相同的含义。

解析此字段时，其行为等同于以下内容：该值在严格和智能模式下验证，但在宽松模式下不验证。该值被拆分为 SECOND_OF_MINUTE 、 MINUTE_OF_HOUR 和 HOUR_OF_DAY 字段。

MINUTE_OF_HOUR

public static final ChronoField  MINUTE_OF_HOUR
            

整点。

这会计算一小时内的分钟数，从 0 到 59。该字段对于所有日历系统具有相同的含义。

解析此字段时，其行为等同于以下内容：该值在严格和智能模式下验证，但在宽松模式下不验证。

MINUTE_OF_DAY

public static final ChronoField  MINUTE_OF_DAY
            

一天中的每一分钟。

这计算一天中的分钟数，从 0 到 (24 * 60) - 1。该字段对于所有日历系统具有相同的含义。

解析此字段时，其行为等同于以下内容：该值在严格和智能模式下验证，但在宽松模式下不验证。该值被拆分为 MINUTE_OF_HOUR 和 HOUR_OF_DAY 字段。

HOUR_OF_AMPM

public static final ChronoField  HOUR_OF_AMPM
            

上午-下午的时间。

这会计算 AM/PM 中的小时数，从 0 到 11。这是在标准 12 小时数字时钟上观察到的小时。该字段对所有日历系统具有相同的含义。

解析此字段时，它的行为等同于以下内容：在严格模式和智能模式下，该值从 0 到 11 进行验证。在宽松模式下，该值未被验证。通过将 AMPM_OF_DAY 值乘以 12，它与 AMPM_OF_DAY 组合形成 HOUR_OF_DAY。

有关从 1 到 12 计算小时数的相关字段，请参阅 CLOCK_HOUR_OF_AMPM 。

CLOCK_HOUR_OF_AMPM

public static final ChronoField  CLOCK_HOUR_OF_AMPM
            

am-pm 的时钟时间。

这会计算 AM/PM 中的小时数，从 1 到 12。这是在标准 12 小时模拟挂钟上观察到的小时。该字段对所有日历系统具有相同的含义。

解析此字段时，其行为等同于以下内容：该值在严格模式下从 1 到 12 进行验证，在智能模式下从 0 到 12 进行验证。在宽松模式下，该值未被验证。该字段将转换为具有相同值的 HOUR_OF_AMPM，除非值为 12，在这种情况下它将转换为 0。

有关从 0 到 11 小时计数的相关字段，请参阅 HOUR_OF_AMPM 。

HOUR_OF_DAY

public static final ChronoField  HOUR_OF_DAY
            

一天中的小时。

这会计算一天中的小时数，从 0 到 23。这是在标准 24 小时数字时钟上观察到的小时。该字段对所有日历系统具有相同的含义。

解析此字段时，其行为等同于以下内容：该值在严格和智能模式下验证，但在宽松模式下不验证。该字段与 MINUTE_OF_HOUR 、 SECOND_OF_MINUTE 和 NANO_OF_SECOND 结合生成一个 LocalTime 。在宽松模式下，任何多余的天数都会添加到解析的日期中，或通过 DateTimeFormatter.parsedExcessDays() 提供。

有关从 1 到 24 小时计数的相关字段，请参阅 CLOCK_HOUR_OF_DAY 。

CLOCK_HOUR_OF_DAY

public static final ChronoField  CLOCK_HOUR_OF_DAY
            

一天中的时钟小时。

这会计算一天中的小时数，从 1 到 24。这是在 24 小时模拟挂钟上观察到的小时。该字段对所有日历系统具有相同的含义。

解析此字段时，其行为等同于以下内容：该值在严格模式下从 1 到 24 进行验证，在智能模式下从 0 到 24 进行验证。在宽松模式下，该值未被验证。该字段将转换为具有相同值的 HOUR_OF_DAY，除非值为 24，在这种情况下它将转换为 0。

有关从 0 到 23 小时计数的相关字段，请参阅 HOUR_OF_DAY 。

AMPM_OF_DAY

public static final ChronoField  AMPM_OF_DAY
            

上午下午。

这会计算一天中的 AM/PM，从 0 (AM) 到 1 (PM)。该字段对所有日历系统具有相同的含义。

解析此字段时，它的行为等同于以下内容：在严格模式和智能模式下，该值从 0 到 1 进行验证。在宽松模式下，该值未被验证。它与 HOUR_OF_AMPM（如果不存在，则默认为“6”）相结合，通过将 AMPM_OF_DAY 值乘以 12 形成 HOUR_OF_DAY。

DAY_OF_WEEK

public static final ChronoField  DAY_OF_WEEK
            

星期几，例如星期二。

这代表了星期几的标准概念。在默认的 ISO 日历系统中，它的值从星期一 (1) 到星期日 (7)。 DayOfWeek 类可用于解释结果。

大多数非 ISO 日历系统还定义了与 ISO 一致的七天工作周。这些日历系统也必须使用相同的编号系统，从星期一 (1) 到星期日 (7)，这允许使用 DayOfWeek。

没有标准七天周的日历系统如果在类似于一周的时间段内具有类似的命名或编号天的概念，则应实现此字段。建议编号从1开始。

ALIGNED_DAY_OF_WEEK_IN_MONTH

public static final ChronoField  ALIGNED_DAY_OF_WEEK_IN_MONTH
            

一个月内对齐的星期几。

这表示一周内的天数概念，其中周数与月初对齐。此字段通常与 ALIGNED_WEEK_OF_MONTH 一起使用。

例如，在每周有 7 天的日历系统中，第一个对齐的月份周从每月的第 1 天开始，第二个对齐的周从第 8 天开始，依此类推。在每个对齐的周内，天数从 1 到 7 并作为该字段的值返回。因此，第 1 到 7 天将具有从 1 到 7 的对齐星期值。第 8 到 14 天将使用从 1 到 7 的对齐星期值重复此操作7.

没有一周七天的日历系统通常应该以相同的方式实现此字段，但使用交替的周长度。

ALIGNED_DAY_OF_WEEK_IN_YEAR

public static final ChronoField  ALIGNED_DAY_OF_WEEK_IN_YEAR
            

一年内对齐的星期几。

这表示一周内的天数概念，其中周数与年初对齐。此字段通常与 ALIGNED_WEEK_OF_YEAR 一起使用。

例如，在每周有 7 天的日历系统中，一年中第一个对齐的星期从一年中的第 1 天开始，第二个对齐的星期从一年中的第 8 天开始，依此类推。在每个对齐的周内，天数从 1 到 7 并作为该字段的值返回。因此，一年中的第 1 天到第 7 天将具有从 1 到 7 的对齐的星期几值。而第 8 到 14 天将使用从 1 到 1 到 7 的对齐的星期几值重复此操作7.

没有一周七天的日历系统通常应该以相同的方式实现此字段，但使用交替的周长度。

DAY_OF_MONTH

public static final ChronoField  DAY_OF_MONTH
            

每月的第几天。

这代表了一个月中的一天的概念。在默认的 ISO 日历系统中，大多数月份的值从 1 到 31。四月、六月、九月、十一月的天数是从 1 到 30，而二月的天数是从 1 到 28，闰年是 29。

非 ISO 日历系统应使用日历系统用户最认可的日期值来实现此字段。通常，这是从 1 到月份长度的天数。

DAY_OF_YEAR

public static final ChronoField  DAY_OF_YEAR
            

一年中的某一天。

这代表了一年中的一天的概念。在默认的 ISO 日历系统中，标准年的值为 1 到 365，闰年的值为 1 到 366。

非 ISO 日历系统应使用日历系统用户最认可的年份值来实现此字段。通常，这是从 1 到一年长度的天数。

请注意，非 ISO 日历系统可能具有年份编号系统，该系统在不同点更改为月份编号中的自然重置。这方面的一个示例是日本日历系统，其中可以在任何日期发生纪元更改，将年份数字重置为 1。时代和年份重置也会导致年中的第几天重置为 1，但不会导致月份或月份中的某天重置为 1。

EPOCH_DAY

public static final ChronoField  EPOCH_DAY
            

纪元日，基于 Java 纪元 1970-01-01 (ISO)。

此字段是 1970-01-01 (ISO) 为零的连续天数。请注意，这使用当地的时间线，忽略偏移量和时区。

该字段被严格定义为在所有日历系统中具有相同的含义。这是确保日历之间的互操作所必需的。

EpochDay 的范围介于 (LocalDate.MIN.toEpochDay(), LocalDate.MAX.toEpochDay()) 之间（包括两者）。

ALIGNED_WEEK_OF_MONTH

public static final ChronoField  ALIGNED_WEEK_OF_MONTH
            

一个月内对齐的一周。

这表示一个月内的周数概念，其中周数与月初对齐。此字段通常与 ALIGNED_DAY_OF_WEEK_IN_MONTH 一起使用。

例如，在每周有 7 天的日历系统中，第一个对齐的月份周从每月的第 1 天开始，第二个对齐的周从第 8 天开始，依此类推。因此，日期值 1 到 7 在对齐的第 1 周，而日期值 8 到 14 在对齐的第 2 周，依此类推。

没有一周七天的日历系统通常应该以相同的方式实现此字段，但使用交替的周长度。

ALIGNED_WEEK_OF_YEAR

public static final ChronoField  ALIGNED_WEEK_OF_YEAR
            

一年内对齐的一周。

这表示一年中的周数概念，其中周数与年初对齐。此字段通常与 ALIGNED_DAY_OF_WEEK_IN_YEAR 一起使用。

例如，在每周有 7 天的日历系统中，一年中第一个对齐的星期从一年中的第 1 天开始，第二个对齐的星期从一年中的第 8 天开始，依此类推。因此，日期值 1 到 7 在对齐的第 1 周，而日期值 8 到 14 在对齐的第 2 周，依此类推。

没有一周七天的日历系统通常应该以相同的方式实现此字段，但使用交替的周长度。

MONTH_OF_YEAR

public static final ChronoField  MONTH_OF_YEAR
            

一年中的月份，例如三月。

这代表了一年中月份的概念。在默认的 ISO 日历系统中，它具有从一月 (1) 到十二月 (12) 的值。

非 ISO 日历系统应使用日历系统用户最认可的月份值来实现此字段。通常，这是从 1 开始的月数。

PROLEPTIC_MONTH

public static final ChronoField  PROLEPTIC_MONTH
            

基于预测月，从第 0 年开始按顺序计算月份。

此字段是月份的连续计数，其中 0 年的第一个月的值为零。后面几个月的值越来越大。前几个月的值越来越小。月份的顺序没有间隙或中断。请注意，这使用当地的时间线，忽略偏移量和时区。

在默认的 ISO 日历系统中，2012 年 6 月的值为 (2012 * 12 + 6 - 1) 。该字段主要供内部使用。

非 ISO 日历系统必须根据上述定义实现此字段。它只是一个简单的从零开始的计数，从 0 年开始计算经过的月数。所有具有完整 proleptic 年定义的日历系统都将有一个零年。如果日历系统有一个不包括零年的最小年份，则必须外推一个以定义此方法。

YEAR_OF_ERA

public static final ChronoField  YEAR_OF_ERA
            

纪元中的年份。

这代表了时代中的年的概念。此字段通常与 ERA 一起使用。

日期的标准心智模型基于三个概念——年、月和日。这些映射到 YEAR、MONTH_OF_YEAR 和 DAY_OF_MONTH 字段。请注意，没有提及时代。日期的完整模型需要四个概念——时代、年、月和日。这些映射到 ERA、YEAR_OF_ERA、MONTH_OF_YEAR 和 DAY_OF_MONTH 字段。是否使用此字段或YEAR 取决于正在使用的心智模型。有关此主题的更多讨论，请参阅 ChronoLocalDate 。

在默认的 ISO 日历系统中，定义了两个纪元，“BCE”和“CE”。纪元“CE”是当前使用的纪元，纪元年份从 1 到最大值。纪元“BCE”是前一个纪元，纪元年份倒退。

例如，每次减去一年会产生以下结果：
- year-proleptic 2 = 'CE' 时代 2
- year-proleptic 1 = 'CE' year-of-era 1
- year-proleptic 0 = 'BCE' 年代 1
- year-proleptic -1 = 'BCE' 纪元 2

请注意，ISO-8601 标准实际上并未定义纪元。另请注意，由于 Julian 和 Gregorian 日历系统之间的变化，ISO 纪元与众所周知的 AD/BC 纪元不一致。

非 ISO 日历系统应使用日历系统用户最认可的年份值来实现此字段。由于大多数日历系统只有两个纪元，纪元年的编号方法通常与 ISO 日历系统使用的方法相同。年份值通常应始终为正，但这不是必需的。

YEAR

public static final ChronoField  YEAR
            

预产期，例如 2012 年。

这代表年的概念，按顺序计算，用负数。预测年不是根据时代来解释的。请参阅 YEAR_OF_ERA ，以获取显示从预兆年到纪年的映射的示例。

日期的标准心智模型基于三个概念——年、月和日。这些映射到 YEAR、MONTH_OF_YEAR 和 DAY_OF_MONTH 字段。请注意，没有提及时代。日期的完整模型需要四个概念——时代、年、月和日。这些映射到 ERA、YEAR_OF_ERA、MONTH_OF_YEAR 和 DAY_OF_MONTH 字段。是否使用此字段或YEAR_OF_ERA 取决于正在使用的心智模型。有关此主题的更多讨论，请参阅 ChronoLocalDate 。

非 ISO 日历系统应按如下方式实现此字段。如果日历系统只有固定日期之前和之后的两个纪元，则预测年值必须与较晚纪元的纪元年值相同，并且对于较早纪元越来越负。如果日历系统有两个以上的纪元，则可以使用任何适当的值定义 proleptic-year 值，尽管将其定义为与 ISO 相同可能是最佳选择。

ERA

public static final ChronoField  ERA
            

时代。

这代表了时代的概念，是时间线最大的划分。此字段通常与 YEAR_OF_ERA 一起使用。

在默认的 ISO 日历系统中，定义了两个纪元，“BCE”和“CE”。纪元“CE”是当前使用的纪元，纪元年份从 1 到最大值。纪元“BCE”是前一个纪元，纪元年份倒退。有关完整示例，请参见 YEAR_OF_ERA 。

非 ISO 日历系统应实现此字段以定义纪元。在 1970-01-01 (ISO) 上处于活动状态的纪元的值必须分配值 1。较早的纪元必须具有依次较小的值。后来的时代必须有连续更大的值，

INSTANT_SECONDS

public static final ChronoField  INSTANT_SECONDS
            

即时纪元秒。

这表示 1970-01-01T00:00Z (ISO) 为零的连续秒数的概念。此字段可与 NANO_OF_SECOND 一起使用以表示秒的小数部分。

Instant 表示时间线上的瞬时点。就其本身而言，瞬间没有足够的信息来获取本地日期时间。只有与偏移量或时区配对才能计算出本地日期或时间。

该字段被严格定义为在所有日历系统中具有相同的含义。这是确保日历之间的互操作所必需的。

OFFSET_SECONDS

public static final ChronoField  OFFSET_SECONDS
            

与 UTC/格林威治的偏移量。

这表示本地时间与 UTC/格林威治时间的偏移量（以秒为单位）的概念。

ZoneOffset 表示当地时间与 UTC/格林威治时间不同的时间段。这通常是固定的小时数和分钟数。它相当于以秒为单位的偏移量的total amount 。例如，在冬季，巴黎的偏移量为 +01:00 ，即 3600 秒。

该字段被严格定义为在所有日历系统中具有相同的含义。这是确保日历之间的互操作所必需的。

方法详情

values

public static ChronoField [] values()
            

返回一个数组，其中包含此枚举类的常量，按照它们声明的顺序排列。

返回：

包含此枚举类常量的数组，按照它们声明的顺序排列

valueOf

public static ChronoField  valueOf(String  name)
            

返回具有指定名称的此类的枚举常量。字符串必须匹配确切地用于在此类中声明枚举常量的标识符。 （不允许使用无关的空白字符。）

参数：

name - 要返回的枚举常量的名称。

返回：

具有指定名称的枚举常量

抛出：

IllegalArgumentException - 如果此枚举类没有具有指定名称的常量

NullPointerException - 如果参数为空

getBaseUnit

public TemporalUnit  getBaseUnit()
            

从接口 TemporalField 复制的描述

获取字段的测量单位。

该字段的单位是在范围内变化的周期。例如，在“MonthOfYear”字段中，单位为“月”。另见 TemporalField.getRangeUnit() 。

指定者：

getBaseUnit 在接口 TemporalField 中

返回：

定义字段基本单位的单位，不为空

getRangeUnit

public TemporalUnit  getRangeUnit()
            

从接口 TemporalField 复制的描述

获取字段绑定的范围。

场的范围是场变化的周期。例如，在“MonthOfYear”字段中，范围是“Years”。另见 TemporalField.getBaseUnit() 。

范围从不为空。例如，“Year”字段是“YearOfForever”的简写。因此，它的单位是“年”，范围是“永远”。

指定者：

getRangeUnit 在接口 TemporalField 中

返回：

定义字段范围的单位，不为空

range

public ValueRange  range()
            

获取字段的有效值范围。

所有字段都可以表示为一个long整数。此方法返回一个描述该值有效范围的对象。

此方法返回字段在 ISO-8601 日历系统中的范围。对于其他日历系统，此范围可能不正确。使用 Chronology.range(ChronoField) 访问不同日历系统的正确范围。

请注意，结果仅描述了最小和最大有效值，重要的是不要过多地解读它们。例如，范围内可能存在对该字段无效的值。

指定者：

range 在接口 TemporalField 中

返回：

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

isDateBased

public boolean isDateBased()
            

检查此字段是否表示日期的组成部分。

从星期几到纪元的字段是基于日期的。

指定者：

isDateBased 在接口 TemporalField 中

返回：

如果它是日期的组成部分则为真

isTimeBased

public boolean isTimeBased()
            

检查此字段是否表示时间的组成部分。

从纳秒到一天中午的字段都是基于时间的。

指定者：

isTimeBased 在接口 TemporalField 中

返回：

如果它是时间的一部分则为真

checkValidValue

public long checkValidValue(long value)
            

检查指定的值是否对此字段有效。

这将验证该值是否在 range() 返回的有效值的外部范围内。

此方法检查 ISO-8601 日历系统中的字段范围。对于其他日历系统，此范围可能不正确。使用 Chronology.range(ChronoField) 访问不同日历系统的正确范围。

参数：

value - 要检查的值

返回：

传入的值

checkValidIntValue

public int checkValidIntValue(long value)
            

检查指定的值是否有效并适合 int 。

这将验证该值是否在 range() 返回的有效值的外部范围内。它还检查所有有效值是否在 int 的范围内。

此方法检查 ISO-8601 日历系统中的字段范围。对于其他日历系统，此范围可能不正确。使用 Chronology.range(ChronoField) 访问不同日历系统的正确范围。

参数：

value - 要检查的值

返回：

传入的值

isSupportedBy

public boolean isSupportedBy(TemporalAccessor  temporal)
            

从接口 TemporalField 复制的描述

检查时间对象是否支持此字段。

这确定时间访问器是否支持此字段。如果返回 false，则无法查询该字段的时间。

有两种等效的方法可以使用此方法。第一种是直接调用此方法。第二种是使用 TemporalAccessor.isSupported(TemporalField) ：

  // these two lines are equivalent, but the second approach is recommended
  temporal = thisField.isSupportedBy(temporal);
  temporal = temporal.isSupported(thisField);
 

推荐使用第二种方法，isSupported(TemporalField)，代码读起来更清晰。

实现应使用 ChronoField 中可用的字段来确定它们是否受支持。

指定者：

isSupportedBy 在接口 TemporalField 中

参数：

temporal - 要查询的时间对象，不为空

返回：

如果可以查询此字段的日期时间，则为 true，否则为 false

rangeRefinedBy

public ValueRange  rangeRefinedBy(TemporalAccessor  temporal)
            

从接口 TemporalField 复制的描述

使用时间对象获取此字段的有效值范围以优化结果。

这使用时间对象来查找字段的有效值范围。这类似于 TemporalField.range() ，但是此方法使用时间优化结果。例如，如果字段为 DAY_OF_MONTH，则 range 方法不准确，因为有四种可能的月份长度，28、29、30 和 31 天。将此方法与日期一起使用可以使范围准确，仅返回这四个选项之一。

有两种等效的方法可以使用此方法。第一种是直接调用此方法。第二种是使用 TemporalAccessor.range(TemporalField) ：

  // these two lines are equivalent, but the second approach is recommended
  temporal = thisField.rangeRefinedBy(temporal);
  temporal = temporal.range(thisField);
 

推荐使用第二种方法，range(TemporalField)，代码读起来更清晰。

实现应使用 ChronoField 中可用的字段执行任何查询或计算。如果不支持该字段，则必须抛出 UnsupportedTemporalTypeException。

指定者：

rangeRefinedBy 在接口 TemporalField 中

参数：

temporal - 用于优化结果的时间对象，不为空

返回：

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

getFrom

public long getFrom(TemporalAccessor  temporal)
            

从接口 TemporalField 复制的描述

从指定的时间对象中获取此字段的值。

这将查询时间对象以获取此字段的值。

有两种等效的方法可以使用此方法。第一种是直接调用此方法。第二种是使用 TemporalAccessor.getLong(TemporalField) （或 TemporalAccessor.get(TemporalField) ）：

  // these two lines are equivalent, but the second approach is recommended
  temporal = thisField.getFrom(temporal);
  temporal = temporal.getLong(thisField);
 

推荐使用第二种方法，getLong(TemporalField)，代码读起来更清晰。

实现应使用 ChronoField 中可用的字段执行任何查询或计算。如果不支持该字段，则必须抛出 UnsupportedTemporalTypeException。

指定者：

getFrom 在接口 TemporalField 中

参数：

temporal - 要查询的时间对象，不为空

返回：

该字段的值，不为空

adjustInto

public <R extends Temporal > R adjustInto(R temporal, long newValue)
            

从接口 TemporalField 复制的描述

返回具有此字段集值的指定时间对象的副本。

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

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

有两种等效的方法可以使用此方法。第一种是直接调用此方法。第二种是使用 Temporal.with(TemporalField, long) ：

  // these two lines are equivalent, but the second approach is recommended
  temporal = thisField.adjustInto(temporal);
  temporal = temporal.with(thisField);
 

推荐使用第二种方法，with(TemporalField)，代码读起来更清晰。

实现应使用 ChronoField 中可用的字段执行任何查询或计算。如果不支持该字段，则必须抛出 UnsupportedTemporalTypeException。

实现不得更改指定的时间对象。相反，必须退回原件的调整副本。这为不可变和可变实现提供了等效的、安全的行为。

指定者：

adjustInto 在接口 TemporalField 中

类型参数：

R - Temporal 对象的类型

参数：

temporal - 要调整的时间对象，不为空

newValue - 字段的新值

返回：

调整后的时间对象，不为空

toString

public String  toString()
            

从类复制的描述：Enum

返回声明中包含的此枚举常量的名称。这个方法可以被重写，尽管它通常不是必需的或不可取的。当存在更“程序员友好”的字符串形式时，枚举类应该重写此方法。

指定者：

toString 在接口 TemporalField 中

重写：

toString 在类 Enum<ChronoField> 中

返回：

此枚举常量的名称