Packages

  • package root
    Definition Classes
    root
  • package java
    Definition Classes
    root
  • package time

    The main API for dates, times, instants, and durations.

    The main API for dates, times, instants, and durations.

    The classes defined here represent the principal date-time concepts, including instants, durations, dates, times, time-zones and periods. They are based on the ISO calendar system, which is the de facto world calendar following the proleptic Gregorian rules. All the classes are immutable and thread-safe.

    Each date time instance is composed of fields that are conveniently made available by the APIs. For lower level access to the fields refer to the org.threeten.bp.temporal package. Each class includes support for printing and parsing all manner of dates and times. Refer to the org.threeten.bp.format package for customization options.

    The org.threeten.bp.chrono package contains the calendar neutral API. This is intended for use by applications that need to use localized calendars. It is recommended that applications use the ISO-8601 dates and time classes from this package across system boundaries, such as to the database or across the network. The calendar neutral API should be reserved for interactions with users.

    Dates and Times

    org.threeten.bp.Instant is essentially a numeric timestamp. The current Instant can be retrieved from a org.threeten.bp.Clock. This is useful for logging and persistence of a point in time and has in the past been associated with storing the result from java.lang.System#currentTimeMillis().

    org.threeten.bp.LocalDate stores a date without a time. This stores a date like '2010-12-03' and could be used to store a birthday.

    org.threeten.bp.LocalTime stores a time without a date. This stores a time like '11:30' and could be used to store an opening or closing time.

    org.threeten.bp.LocalDateTime stores a date and time. This stores a date-time like '2010-12-03T11:30'.

    org.threeten.bp.OffsetTime stores a time and offset from UTC without a date. This stores a date like '11:30+01:00'. The ZoneOffset is of the form '+01:00'.

    org.threeten.bp.OffsetDateTime stores a date and time and offset from UTC. This stores a date-time like '2010-12-03T11:30+01:00'. This is sometimes found in XML messages and other forms of persistence, but contains less information than a full time-zone.

    org.threeten.bp.ZonedDateTime stores a date and time with a time-zone. This is useful if you want to perform accurate calculations of dates and times taking into account the org.threeten.bp.ZoneId, such as 'Europe/Paris'. Where possible, it is recommended to use a simpler class. The widespread use of time-zones tends to add considerable complexity to an application.

    Duration and Period

    Beyond dates and times, the API also allows the storage of period and durations of time. A org.threeten.bp.Duration is a simple measure of time along the time-line in nanoseconds. A org.threeten.bp.Period expresses an amount of time in units meaningful to humans, such as years or hours.

    Additional value types

    org.threeten.bp.Year stores a year on its own. This stores a single year in isolation, such as '2010'.

    org.threeten.bp.YearMonth stores a year and month without a day or time. This stores a year and month, such as '2010-12' and could be used for a credit card expiry.

    org.threeten.bp.MonthDay stores a month and day without a year or time. This stores a month and day-of-month, such as '--12-03' and could be used to store an annual event like a birthday without storing the year.

    org.threeten.bp.Month stores a month on its own. This stores a single month-of-year in isolation, such as 'DECEMBER'.

    org.threeten.bp.DayOfWeek stores a day-of-week on its own. This stores a single day-of-week in isolation, such as 'TUESDAY'.

    Definition Classes
    java
  • package temporal

    Access to date and time using fields and units.

    Access to date and time using fields and units.

    This package expands on the base package to provide additional functionality for more powerful use cases. Support is included for:

    • Units of date-time, such as years, months, days and hours
    • Fields of date-time, such as month-of-year, day-of-week or hour-of-day
    • Date-time adjustment functions
    • Different definitions of weeks

    Fields and Units

    Dates and times are expressed in terms of fields and units. A unit is used to measure an amount of time, such as years, days or minutes. All units implement org.threeten.bp.temporal.TemporalUnit. The set of well known units is defined in org.threeten.bp.temporal.ChronoUnit, for example, org.threeten.bp.temporal.ChronoUnit#DAYS. The unit interface is designed to allow applications to add their own units.

    A field is used to express part of a larger date-time, such as year, month-of-year or second-of-minute. All fields implement org.threeten.bp.temporal.TemporalField. The set of well known fields are defined in org.threeten.bp.temporal.ChronoField, for example, org.threeten.bp.temporal.ChronoField#HOUR_OF_DAY. An additional fields are defined by org.threeten.bp.temporal.JulianFields. The field interface is designed to allow applications to add their own fields.

    This package provides tools that allow the units and fields of date and time to be accessed in a general way most suited for frameworks. org.threeten.bp.temporal.Temporal provides the abstraction for date time types that support fields. Its methods support getting the value of a field, creating a new date time with the value of a field modified, and extracting another date time type, typically used to extract the offset or time-zone.

    One use of fields in application code is to retrieve fields for which there is no convenience method. For example, getting the day-of-month is common enough that there is a method on LocalDate called getDayOfMonth(). However for more unusual fields it is necessary to use the field. For example, date.get(ChronoField.ALIGNED_WEEK_OF_MONTH). The fields also provide access to the range of valid values.

    Adjustment

    A key part of the date-time problem space is adjusting a date to a new, related value, such as the "last day of the month", or "next Wednesday". These are modeled as functions that adjust a base date-time. The functions implement org.threeten.bp.temporal.TemporalAdjuster and operate on org.threeten.bp.temporal.Temporal. A set of common functions are provided in org.threeten.bp.temporal.TemporalAdjusters. For example, to find the first occurrence of a day-of-week after a given date, use org.threeten.bp.temporal.TemporalAdjusters#next(DayOfWeek), such as date.with(next(MONDAY)).

    Weeks

    Different locales have different definitions of the week. For example, in Europe the week typically starts on a Monday, while in the US it starts on a Sunday. The org.threeten.bp.temporal.WeekFields class models this distinction.

    The ISO calendar system defines an additional week-based division of years. This defines a year based on whole Monday to Monday weeks. This is modeled in org.threeten.bp.temporal.IsoFields.

    Definition Classes
    time
  • ChronoField
  • ChronoUnit
  • IsoFields
  • JulianFields
  • Temporal
  • TemporalAccessor
  • TemporalAdjuster
  • TemporalAdjusters
  • TemporalAmount
  • TemporalField
  • TemporalQueries
  • TemporalQuery
  • TemporalUnit
  • UnsupportedTemporalTypeException
  • ValueRange
  • WeekFields
t

java.time.temporal

TemporalField

trait TemporalField extends AnyRef

A field of date-time, such as month-of-year or hour-of-minute.

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.

Specification for implementors

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.

Linear Supertypes
AnyRef, Any
Known Subclasses
ChronoField
Ordering
  1. Alphabetic
  2. By Inheritance
Inherited
  1. TemporalField
  2. AnyRef
  3. Any
  1. Hide All
  2. Show All
Visibility
  1. Public
  2. All

Abstract Value Members

  1. abstract def adjustInto[R <: Temporal](temporal: R, newValue: Long): R

    Returns a copy of the specified temporal object with the value of this field set.

    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 LocalDate, this could be used to set the year, month or day-of-month. The returned object has the same observable type as the specified object.

    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 long): 

    // 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 ChronoField. If the field is not supported a DateTimeException must be thrown.

    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.

    R

    the type of the Temporal object

    temporal

    the temporal object to adjust, not null

    newValue

    the new value of the field

    returns

    the adjusted temporal object, not null

    Exceptions thrown

    DateTimeException if the field cannot be set

  2. abstract def getBaseUnit: TemporalUnit

    Gets the unit that the field is measured in.

    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 #getRangeUnit().

    returns

    the period unit defining the base unit of the field, not null

  3. abstract def getDisplayName(locale: Locale): String

    Gets the display name for the field in the requested 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 toString().

    locale

    the locale to use, not null

    returns

    the display name for the locale or a suitable default, not null

  4. abstract def getFrom(temporal: TemporalAccessor): Long

    Gets the value of this field from the specified temporal object.

    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 TemporalAccessor#getLong(TemporalField) (or TemporalAccessor#get(TemporalField)): 

    // 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 ChronoField. If the field is not supported a DateTimeException must be thrown.

    temporal

    the temporal object to query, not null

    returns

    the value of this field, not null

    Exceptions thrown

    DateTimeException if a value for the field cannot be obtained

  5. abstract def getRangeUnit: TemporalUnit

    Gets the range that the field is bound by.

    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 #getBaseUnit().

    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'.

    returns

    the period unit defining the range of the field, not null

  6. abstract def isDateBased: Boolean

    Checks if this field is date-based.

    Checks if this field is date-based.

    A date-based field can be derived from epoch-day

    returns

    true if date-based

  7. abstract def isSupportedBy(temporal: TemporalAccessor): Boolean

    Checks if this field is supported by the temporal object.

    Checks if this field is supported by the temporal object.

    This determines whether the temporal accessor supports this field. If this returns false, the 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 TemporalAccessor#isSupported(TemporalField): 

    // 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 ChronoField.

    temporal

    the temporal object to query, not null

    returns

    true if the date-time can be queried for this field, false if not

  8. abstract def isTimeBased: Boolean

    Checks if this field is time-based.

    Checks if this field is time-based.

    A time-based field can be derived from nano-of-day

    returns

    true if time-based

  9. abstract def range: ValueRange

    Gets the range of valid values for the field.

    Gets the range of valid values for the field.

    All fields can be expressed as a long integer. This method returns an object that describes the valid range for that value. This method is generally only applicable to the ISO-8601 calendar system.

    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.

    returns

    the range of valid values for the field, not null

  10. abstract def rangeRefinedBy(temporal: TemporalAccessor): ValueRange

    Get the range of valid values for this field using the temporal object to refine the result.

    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 #range(), however this method refines the result using the temporal. For example, if the field is DAY_OF_MONTH the range method is not accurate as there are four possible month lengths, 28, 29, 30 and 31 days. Using this method with a date allows the range to be accurate, returning just one of those four options.

    There are two equivalent ways of using this method. The first is to invoke this method directly. The second is to use TemporalAccessor#range(TemporalField): 

    // 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 ChronoField. If the field is not supported a DateTimeException must be thrown.

    temporal

    the temporal object used to refine the result, not null

    returns

    the range of valid values for this field, not null

    Exceptions thrown

    DateTimeException if the range for the field cannot be obtained

  11. abstract def resolve(fieldValues: Map[TemporalField, Long], partialTemporal: TemporalAccessor, resolverStyle: ResolverStyle): TemporalAccessor

    Resolves the date/time information in the builder

    Resolves the date/time information in the builder

    This method is invoked during the resolve of the builder. Implementations should combine the associated field with others to form objects like LocalDate, LocalTime and LocalDateTime

    fieldValues

    the map of fields to values, which can be updated, not null

    partialTemporal

    the partially complete temporal to query for zone and chronology; querying for other things is undefined and not recommended, not null

    resolverStyle

    the requested type of resolve, not null

    returns

    the resolved temporal object; null if resolving only changed the map, or no resolve occurred

    Exceptions thrown

    ArithmeticException if numeric overflow occurs

    DateTimeException if resolving results in an error. This must not be thrown by querying a field on the temporal without first checking if it is supported

Concrete Value Members

  1. final def !=(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  2. final def ##(): Int
    Definition Classes
    AnyRef → Any
  3. final def ==(arg0: Any): Boolean
    Definition Classes
    AnyRef → Any
  4. final def asInstanceOf[T0]: T0
    Definition Classes
    Any
  5. def clone(): AnyRef
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.CloneNotSupportedException]) @native()
  6. final def eq(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  7. def equals(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef → Any
  8. def finalize(): Unit
    Attributes
    protected[java.lang]
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.Throwable])
  9. final def getClass(): Class[_ <: AnyRef]
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  10. def hashCode(): Int
    Definition Classes
    AnyRef → Any
    Annotations
    @native()
  11. final def isInstanceOf[T0]: Boolean
    Definition Classes
    Any
  12. final def ne(arg0: AnyRef): Boolean
    Definition Classes
    AnyRef
  13. final def notify(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  14. final def notifyAll(): Unit
    Definition Classes
    AnyRef
    Annotations
    @native()
  15. final def synchronized[T0](arg0: => T0): T0
    Definition Classes
    AnyRef
  16. def toString(): String
    Definition Classes
    AnyRef → Any
  17. final def wait(): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  18. final def wait(arg0: Long, arg1: Int): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException])
  19. final def wait(arg0: Long): Unit
    Definition Classes
    AnyRef
    Annotations
    @throws(classOf[java.lang.InterruptedException]) @native()

Inherited from AnyRef

Inherited from Any

Ungrouped