Date and time is expressed using fields which partition the time-line into something meaningful for humans. Implementations of this interface represent those fields.
The most commonly used units are defined in ChronoField.
Further fields are supplied in IsoFields, WeekFields and JulianFields.
Fields can also be written by application code by implementing this interface.
The field works using double dispatch. Client code calls methods on a date-time like
LocalDateTime which check if the field is a ChronoField.
If it is, then the date-time must handle it.
Otherwise, the method call is re-dispatched to the matching method in this interface.
Implementation Specification
This interface must be implemented with care to ensure other classes operate correctly.
All implementations that can be instantiated must be final, immutable and thread-safe.
Implementations should be Serializable where possible.
An enum is as effective implementation choice.
| Modifier and Type | Method and Description |
|---|---|
| public < the type of the Temporal object R extends Temporal> R | Returns: the adjusted temporal object, not nullthe temporal object to adjust, not null temporal, long the new value of the field newValue)Returns a copy of the specified temporal object with the value of this field set. |
| public TemporalUnit | Returns: the unit defining the base unit of the field, not nullGets the unit that the field is measured in. The unit of the field is the period that varies within the range. |
| public default String | Returns: the display name for the locale or a suitable default, not nullthe locale to use, not null locale)Gets the display name for the field in the requested locale. |
| public long | Returns: the value of this field, not nullthe temporal object to query, not null temporal)Gets the value of this field from the specified temporal object. |
| public TemporalUnit | Returns: the unit defining the range of the field, not nullGets the range that the field is bound by. |
| public boolean | Returns: true if this field is a component of a dateChecks if this field represents a component of a date. |
| public boolean | Returns: true if the date-time can be queried for this field, false if notthe temporal object to query, not null temporal)Checks if this field is supported by the temporal object. |
| public boolean | Returns: true if this field is a component of a timeChecks if this field represents a component of a time. |
| public ValueRange | Returns: the range of valid values for the field, not nullGets the range of valid values for the field. |
| public ValueRange | Returns: the range of valid values for this field, not nullthe temporal object used to refine the result, not null temporal)Get the range of valid values for this field using the temporal object to refine the result. |
| public default TemporalAccessor | Returns: the resolved temporal object; null if resolving only changed the map, or no resolve occurredthe map of fields to values, which can be updated, not null fieldValues, TemporalAccessor the partially complete temporal to query for zone and
chronology; querying for other things is undefined and not recommended, not null partialTemporal, ResolverStyle the requested type of resolve, not null resolverStyle)Resolves this field to provide a simpler alternative or a date. |
| public String |
| adjustInto | back to summary |
|---|---|
| public <R extends Temporal> R adjustInto(R temporal, long newValue) Returns a copy of the specified temporal object with the value of this field set.
This returns a new temporal object based on the specified one with the value for
this field changed. For example, on a In some cases, changing a field is not fully defined. For example, if the target object is a date representing the 31st January, then changing the month to February would be unclear. In cases like this, the implementation is responsible for resolving the result. Typically it will choose the previous valid date, which would be the last valid day of February in this example.
There are two equivalent ways of using this method.
The first is to invoke this method directly.
The second is to use // these two lines are equivalent, but the second approach is recommended temporal = thisField.adjustInto(temporal); temporal = temporal.with(thisField);It is recommended to use the second approach, with(TemporalField),
as it is a lot clearer to read in code.
Implementations should perform any queries or calculations using the fields
available in Implementations must not alter the specified temporal object. Instead, an adjusted copy of the original must be returned. This provides equivalent, safe behavior for immutable and mutable implementations.
| |
| getBaseUnit | back to summary |
|---|---|
| public TemporalUnit getBaseUnit() Gets the unit that the field is measured in.
The unit of the field is the period that varies within the range.
For example, in the field 'MonthOfYear', the unit is 'Months'.
See also
| |
| getDisplayName | back to summary |
|---|---|
| public default String getDisplayName(Locale locale) Gets the display name for the field in the requested locale. If there is no display name for the locale then a suitable default must be returned.
The default implementation must check the locale is not null
and return | |
| getFrom | back to summary |
|---|---|
| public long getFrom(TemporalAccessor temporal) Gets the value of this field from the specified temporal object. This queries the temporal object for the value of this field.
There are two equivalent ways of using this method.
The first is to invoke this method directly.
The second is to use // these two lines are equivalent, but the second approach is recommended temporal = thisField.getFrom(temporal); temporal = temporal.getLong(thisField);It is recommended to use the second approach, getLong(TemporalField),
as it is a lot clearer to read in code.
Implementations should perform any queries or calculations using the fields
available in
| |
| getRangeUnit | back to summary |
|---|---|
| public TemporalUnit getRangeUnit() Gets the range that the field is bound by.
The range of the field is the period that the field varies within.
For example, in the field 'MonthOfYear', the range is 'Years'.
See also The range is never null. For example, the 'Year' field is shorthand for 'YearOfForever'. It therefore has a unit of 'Years' and a range of 'Forever'.
| |
| isDateBased | back to summary |
|---|---|
| public boolean isDateBased() Checks if this field represents a component of a date.
A field is date-based if it can be derived from
| |
| isSupportedBy | back to summary |
|---|---|
| public boolean isSupportedBy(TemporalAccessor temporal) Checks if this field is supported by the temporal object. This determines whether the temporal accessor supports this field. If this returns false, then the temporal cannot be queried for this field.
There are two equivalent ways of using this method.
The first is to invoke this method directly.
The second is to use // these two lines are equivalent, but the second approach is recommended temporal = thisField.isSupportedBy(temporal); temporal = temporal.isSupported(thisField);It is recommended to use the second approach, isSupported(TemporalField),
as it is a lot clearer to read in code.
Implementations should determine whether they are supported using the fields
available in
| |
| isTimeBased | back to summary |
|---|---|
| public boolean isTimeBased() Checks if this field represents a component of a time.
A field is time-based if it can be derived from
| |
| range | back to summary |
|---|---|
| public ValueRange range() Gets the range of valid values for the field.
All fields can be expressed as a Note that the result only describes the minimum and maximum valid values and it is important not to read too much into them. For example, there could be values within the range that are invalid for the field.
| |
| rangeRefinedBy | back to summary |
|---|---|
| public ValueRange rangeRefinedBy(TemporalAccessor temporal) Get the range of valid values for this field using the temporal object to refine the result.
This uses the temporal object to find the range of valid values for the field.
This is similar to
There are two equivalent ways of using this method.
The first is to invoke this method directly.
The second is to use // these two lines are equivalent, but the second approach is recommended temporal = thisField.rangeRefinedBy(temporal); temporal = temporal.range(thisField);It is recommended to use the second approach, range(TemporalField),
as it is a lot clearer to read in code.
Implementations should perform any queries or calculations using the fields
available in
| |
| resolve | back to summary |
|---|---|
| public default TemporalAccessor resolve(Map<TemporalField, Long> fieldValues, TemporalAccessor partialTemporal, ResolverStyle resolverStyle) Resolves this field to provide a simpler alternative or a date.
This method is invoked during the resolve phase of parsing.
It is designed to allow application defined fields to be simplified into
more standard fields, such as those on Applications should not normally invoke this method directly. Implementation Specification If an implementation represents a field that can be simplified, or combined with others, then this method must be implemented. The specified map contains the current state of the parse. The map is mutable and must be mutated to resolve the field and any related fields. This method will only be invoked during parsing if the map contains this field, and implementations should therefore assume this field is present.
Resolving a field will consist of looking at the value of this field,
and potentially other fields, and either updating the map with a
simpler value, such as a
For example, the
A partially complete temporal is used to allow the chronology and zone
to be queried. In general, only the chronology will be needed.
Querying items other than the zone or chronology is undefined and
must not be relied on.
The behavior of other methods such as
If resolution should be possible, but the data is invalid, the resolver
style should be used to determine an appropriate level of leniency, which
may require throwing a
When resolving time fields, the map will be altered and null returned.
When resolving date fields, the date is normally returned from the method,
with the map altered to remove the resolved fields. However, it would also
be acceptable for the date fields to be resolved into other
Not all The default implementation must return null.
| |
| toString | back to summary |
|---|---|
| public String toString() Gets a descriptive name for the field.
The should be of the format 'BaseOfRange', such as 'MonthOfYear',
unless the field has a range of | |