Home Reference Source
import {Instant} from 'js-joda/src/Instant.js'
public class | source

Instant

Extends:

TemporalAccessorTemporal → Instant

An instantaneous point on the time-line.

This class models a single instantaneous point on the time-line. This might be used to record event time-stamps in the application.

Time-scale

The length of the solar day is the standard way that humans measure time. This has traditionally been subdivided into 24 hours of 60 minutes of 60 seconds, forming a 86400 second day.

Modern timekeeping is based on atomic clocks which precisely define an SI second relative to the transitions of a Caesium atom. The length of an SI second was defined to be very close to the 86400th fraction of a day.

Unfortunately, as the Earth rotates the length of the day varies. In addition, over time the average length of the day is getting longer as the Earth slows. As a result, the length of a solar day in 2012 is slightly longer than 86400 SI seconds. The actual length of any given day and the amount by which the Earth is slowing are not predictable and can only be determined by measurement. The UT1 time-scale captures the accurate length of day, but is only available some time after the day has completed.

The UTC time-scale is a standard approach to bundle up all the additional fractions of a second from UT1 into whole seconds, known as leap-seconds. A leap-second may be added or removed depending on the Earth's rotational changes. As such, UTC permits a day to have 86399 SI seconds or 86401 SI seconds where necessary in order to keep the day aligned with the Sun.

The modern UTC time-scale was introduced in 1972, introducing the concept of whole leap-seconds. Between 1958 and 1972, the definition of UTC was complex, with minor sub-second leaps and alterations to the length of the notional second. As of 2012, discussions are underway to change the definition of UTC again, with the potential to remove leap seconds or introduce other changes.

Given the complexity of accurate timekeeping described above, this Java API defines its own time-scale, the Java Time-Scale.

The Java Time-Scale divides each calendar day into exactly 86400 subdivisions, known as seconds. These seconds may differ from the SI second. It closely matches the de facto international civil time scale, the definition of which changes from time to time.

The Java Time-Scale has slightly different definitions for different segments of the time-line, each based on the consensus international time scale that is used as the basis for civil time. Whenever the internationally-agreed time scale is modified or replaced, a new segment of the Java Time-Scale must be defined for it. Each segment must meet these requirements:

  • the Java Time-Scale shall closely match the underlying international civil time scale;
  • the Java Time-Scale shall exactly match the international civil time scale at noon each day;
  • the Java Time-Scale shall have a precisely-defined relationship to the international civil time scale.

There are currently, as of 2013, two segments in the Java time-scale.

For the segment from 1972-11-03 (exact boundary discussed below) until further notice, the consensus international time scale is UTC (with leap seconds). In this segment, the Java Time-Scale is identical to UTC-SLS. This is identical to UTC on days that do not have a leap second. On days that do have a leap second, the leap second is spread equally over the last 1000 seconds of the day, maintaining the appearance of exactly 86400 seconds per day.

For the segment prior to 1972-11-03, extending back arbitrarily far, the consensus international time scale is defined to be UT1, applied proleptically, which is equivalent to the (mean) solar time on the prime meridian (Greenwich). In this segment, the Java Time-Scale is identical to the consensus international time scale. The exact boundary between the two segments is the instant where UT1 = UTC between 1972-11-03T00:00 and 1972-11-04T12:00.

Implementations of the Java time-scale using the JSR-310 API are not required to provide any clock that is sub-second accurate, or that progresses monotonically or smoothly. Implementations are therefore not required to actually perform the UTC-SLS slew or to otherwise be aware of leap seconds. JSR-310 does, however, require that implementations must document the approach they use when defining a clock representing the current instant. See Clock for details on the available clocks.

The Java time-scale is used for all date-time classes. This includes Instant, LocalDate, LocalTime, OffsetDateTime, ZonedDateTime and Duration.

Static properties of Class Instant

Instant.EPOCH

Instant.MIN

Instant.MAX

Instant.MIN_SECONDS

Instant.MAX_SECONDS

Static Method Summary

Static Public Methods
public static

Obtains an instance of Instant from a temporal object.

public static

now(clock: Clock): Instant

Obtains the current instant from the system clock, or if specified the current instant from the specified clock.

public static

ofEpochMilli(epochMilli: number): Instant

Obtains an instance of Instant using milliseconds from the epoch of 1970-01-01T00:00:00Z.

public static

ofEpochSecond(epochSecond: number, nanoAdjustment: number): Instant

Obtains an instance of Instant using seconds from the epoch of 1970-01-01T00:00:00Z.

public static

parse(text: string): Instant

Obtains an instance of Instant from a text string such as 2007-12-03T10:15:30.000Z.

Method Summary

Public Methods
public

Adjusts the specified temporal object to have this instant.

public

compareTo(otherInstant: Instant): number

Compares this instant to the specified instant.

public

Gets the number of seconds from the Java epoch of 1970-01-01T00:00:00Z.

public

equals(otherInstant: *): boolean

Checks if this instant is equal to the specified instant.

public

Gets the value of the specified field from this instant as an int.

public

Gets the value of the specified field from this instant as a long.

public

Returns a hash code for this instant.

public

isAfter(otherInstant: Instant): boolean

Checks if this instant is after the specified instant.

public

isBefore(otherInstant: Instant): boolean

Checks if this instant is before the specified instant.

public

Checks if the specified field is supported.

public
public
public

minus2(amountToSubtract: number, unit: TemporalUnit): Instant

public

minusMillis(millisToSubtract: number): Instant

Returns a copy of this instant with the specified duration in milliseconds subtracted.

public

minusNanos(nanosToSubtract: number): Instant

Returns a copy of this instant with the specified duration in nanoseconds subtracted.

public

minusSeconds(secondsToSubtract: number): Instant

Returns a copy of this instant with the specified duration in seconds subtracted.

public

Gets the number of nanoseconds, later along the time-line, from the start of the second.

public
public
public

plus2(amountToAdd: number, unit: TemporalUnit): Instant

public

plusMillis(millisToAdd: number): Instant

Returns a copy of this instant with the specified duration in milliseconds added.

public

plusNanos(nanosToAdd: number): Instant

Returns a copy of this instant with the specified duration in nanoseconds added.

public

plusSeconds(secondsToAdd: number): Instant

Returns a copy of this instant with the specified duration in seconds added.

public

query(query: TemporalQuery): *

Queries this instant using the specified query.

public

Gets the range of valid values for the specified field.

public

Converts this instant to the number of milliseconds from the epoch of 1970-01-01T00:00:00Z.

public
public

A string representation of this instant using ISO-8601 representation.

public

Returns a copy of this Instant truncated to the specified unit.

public

until(endExclusive: Temporal, unit: TemporalUnit): number

Calculates the period between this instant and another instant in terms of the specified unit.

public

with(adjusterOrField: TemporalAdjuster | TemporalField, newValue: number): Instant

function overloading for Instant.with

public

with2(field: TemporalField, newValue: number): Instant

Returns a copy of this instant with the specified field set to a new value.

public

Returns an adjusted copy of this instant.

Inherited Summary

From class TemporalAccessor
public

Gets the value of the specified field as an int.

public

query(query: TemporalQuery): *

Queries this date-time.

public

Gets the range of valid values for the specified field.

Static Public Methods

public static from(temporal: TemporalAccessor): Instant source

Obtains an instance of Instant from a temporal object.

A TemporalAccessor represents some form of date and time information. This factory converts the arbitrary temporal object to an instance of Instant.

The conversion extracts the ChronoField#INSTANT_SECONDS and ChronoField#NANO_OF_SECOND fields.

This method matches the signature of the functional interface TemporalQuery allowing it to be used as a query via method reference, Instant::from.

Params:

NameTypeAttributeDescription
temporal TemporalAccessor

the temporal object to convert, not null

Return:

Instant

the instant, not null

Throw:

*

DateTimeException if unable to convert to an Instant

public static now(clock: Clock): Instant source

Obtains the current instant from the system clock, or if specified the current instant from the specified clock.

This will query the specified clock to obtain the current time.

Params:

NameTypeAttributeDescription
clock Clock
  • optional
  • default: Clock.systemUTC()

the clock to use, defaults to the system clock

Return:

Instant

the current instant, not null

public static ofEpochMilli(epochMilli: number): Instant source

Obtains an instance of Instant using milliseconds from the epoch of 1970-01-01T00:00:00Z.

The seconds and nanoseconds are extracted from the specified milliseconds.

Params:

NameTypeAttributeDescription
epochMilli number

the number of milliseconds from 1970-01-01T00:00:00Z

Return:

Instant

an instant, not null

Throw:

*

DateTimeException if the instant exceeds the maximum or minimum instant

public static ofEpochSecond(epochSecond: number, nanoAdjustment: number): Instant source

Obtains an instance of Instant using seconds from the epoch of 1970-01-01T00:00:00Z.

Params:

NameTypeAttributeDescription
epochSecond number

the number of seconds from 1970-01-01T00:00:00Z

nanoAdjustment number

nanoseconds start from the start of epochSecond, if null the nanosecond field is set to zero.

Return:

Instant

an instant, not null

Throw:

*

DateTimeException if the instant exceeds the maximum or minimum instant

public static parse(text: string): Instant source

Obtains an instance of Instant from a text string such as 2007-12-03T10:15:30.000Z.

The string must represent a valid instant in UTC and is parsed using DateTimeFormatter#ISO_INSTANT.

Params:

NameTypeAttributeDescription
text string

the text to parse, not null

Return:

Instant

the parsed instant, not null

Throw:

*

DateTimeParseException if the text cannot be parsed

Public Methods

public adjustInto(temporal: Temporal): Temporal source

Adjusts the specified temporal object to have this instant.

This returns a temporal object of the same observable type as the input with the instant changed to be the same as this.

The adjustment is equivalent to using Temporal#with twice, passing ChronoField#INSTANT_SECONDS and ChronoField#NANO_OF_SECOND as the fields.

In most cases, it is clearer to reverse the calling pattern by using Temporal#with:

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

This instance is immutable and unaffected by this method call.

Params:

NameTypeAttributeDescription
temporal Temporal
  • nullable: false

the target object to be adjusted, not null

Return:

Temporal

the adjusted object, not null

Throw:

*

DateTimeException if unable to make the adjustment

*

ArithmeticException if numeric overflow occurs

public compareTo(otherInstant: Instant): number source

Compares this instant to the specified instant.

The comparison is based on the time-line position of the instants. It is "consistent with equals", as defined by Comparable.

Params:

NameTypeAttributeDescription
otherInstant Instant

the other instant to compare to, not null

Return:

number

the comparator value, negative if less, positive if greater

Throw:

*

NullPointerException if otherInstant is null

public epochSecond(): number source

Gets the number of seconds from the Java epoch of 1970-01-01T00:00:00Z.

The epoch second count is a simple incrementing count of seconds where second 0 is 1970-01-01T00:00:00Z. The nanosecond part of the day is returned by getNanosOfSecond.

Return:

number

the seconds from the epoch of 1970-01-01T00:00:00Z

public equals(otherInstant: *): boolean source

Checks if this instant is equal to the specified instant.

The comparison is based on the time-line position of the instants.

Params:

NameTypeAttributeDescription
otherInstant *

the other instant, null/ undefined returns false

Return:

boolean

true if the other instant is equal to this one

public get(field: TemporalField): number source

Gets the value of the specified field from this instant as an int.

This queries this instant for the value for the specified field. The returned value will always be within the valid range of values for the field. If it is not possible to return the value, because the field is not supported or for some other reason, an exception is thrown.

If the field is a ChronoField then the query is implemented here. The supported fields (see isSupported) will return valid values based on this date-time, except INSTANT_SECONDS which is too large to fit in an int and throws a DateTimeException. All other ChronoField instances will throw a DateTimeException.

If the field is not a ChronoField, then the result of this method is obtained by invoking TemporalField.getFrom passing this as the argument. Whether the value can be obtained, and what the value represents, is determined by the field.

Override:

TemporalAccessor#get

Params:

NameTypeAttributeDescription
field TemporalField

the field to get, not null

Return:

number

the value for the field

Throw:

*

DateTimeException if a value for the field cannot be obtained

*

ArithmeticException if numeric overflow occurs

public getLong(field: TemporalField): number source

Gets the value of the specified field from this instant as a long.

This queries this instant for the value for the specified field. If it is not possible to return the value, because the field is not supported or for some other reason, an exception is thrown.

If the field is a ChronoField then the query is implemented here. The supported fields (see isSupported) will return valid values based on this date-time. All other ChronoField instances will throw a DateTimeException.

If the field is not a ChronoField, then the result of this method is obtained by invoking TemporalField.getFrom passing this as the argument. Whether the value can be obtained, and what the value represents, is determined by the field.

Params:

NameTypeAttributeDescription
field TemporalField

the field to get, not null

Return:

number

the value for the field

Throw:

*

DateTimeException if a value for the field cannot be obtained

*

ArithmeticException if numeric overflow occurs

public hashCode(): number source

Returns a hash code for this instant.

Return:

number

a suitable hash code

public isAfter(otherInstant: Instant): boolean source

Checks if this instant is after the specified instant.

The comparison is based on the time-line position of the instants.

Params:

NameTypeAttributeDescription
otherInstant Instant

the other instant to compare to, not null

Return:

boolean

true if this instant is after the specified instant

Throw:

*

NullPointerException if otherInstant is null

public isBefore(otherInstant: Instant): boolean source

Checks if this instant is before the specified instant.

The comparison is based on the time-line position of the instants.

Params:

NameTypeAttributeDescription
otherInstant Instant

the other instant to compare to, not null

Return:

boolean

true if this instant is before the specified instant

Throw:

*

NullPointerException if otherInstant is null

public isSupported(fieldOrUnit: TemporalField | TemporalUnit): boolean source

Checks if the specified field is supported.

This checks if this instant can be queried for the specified field. If false, then calling range and get will throw an exception.

If the field is a ChronoField then the query is implemented here. The supported fields are:

  • NANO_OF_SECOND
  • MICRO_OF_SECOND
  • MILLI_OF_SECOND
  • INSTANT_SECONDS

All other ChronoField instances will return false.

If the field is not a ChronoField, then the result of this method is obtained by invoking TemporalField.isSupportedBy passing this as the argument. Whether the field is supported is determined by the field.

Params:

NameTypeAttributeDescription
fieldOrUnit TemporalField | TemporalUnit

the field to check, null returns false

Return:

boolean

true if the field is supported on this instant, false if not

public minus(amount: TemporalAmount | number, unit: TemporalUnit): Instant source

Params:

NameTypeAttributeDescription
amount TemporalAmount | number
unit TemporalUnit

only required if first param is a TemporalAmount

Return:

Instant

public minus1(amount: TemporalAmount): Instant source

Params:

NameTypeAttributeDescription
amount TemporalAmount
  • nullable: false

Return:

Instant

Throw:

*

DateTimeException

*

ArithmeticException

public minus2(amountToSubtract: number, unit: TemporalUnit): Instant source

Params:

NameTypeAttributeDescription
amountToSubtract number
  • nullable: false
unit TemporalUnit
  • nullable: false

Return:

Instant

Throw:

*

DateTimeException

*

ArithmeticException

public minusMillis(millisToSubtract: number): Instant source

Returns a copy of this instant with the specified duration in milliseconds subtracted.

This instance is immutable and unaffected by this method call.

Params:

NameTypeAttributeDescription
millisToSubtract number

the milliseconds to subtract, positive or negative

Return:

Instant

an Instant based on this instant with the specified milliseconds subtracted, not null

Throw:

*

DateTimeException if the result exceeds the maximum or minimum instant

*

ArithmeticException if numeric overflow occurs

public minusNanos(nanosToSubtract: number): Instant source

Returns a copy of this instant with the specified duration in nanoseconds subtracted.

This instance is immutable and unaffected by this method call.

Params:

NameTypeAttributeDescription
nanosToSubtract number

the nanoseconds to subtract, positive or negative

Return:

Instant

an Instant based on this instant with the specified nanoseconds subtracted, not null

Throw:

*

DateTimeException if the result exceeds the maximum or minimum instant

*

ArithmeticException if numeric overflow occurs

public minusSeconds(secondsToSubtract: number): Instant source

Returns a copy of this instant with the specified duration in seconds subtracted.

This instance is immutable and unaffected by this method call.

Params:

NameTypeAttributeDescription
secondsToSubtract number

the seconds to subtract, positive or negative

Return:

Instant

an Instant based on this instant with the specified seconds subtracted, not null

Throw:

*

DateTimeException if the result exceeds the maximum or minimum instant

public nano(): number source

Gets the number of nanoseconds, later along the time-line, from the start of the second.

The nanosecond-of-second value measures the total number of nanoseconds from the second returned by getEpochSecond.

Return:

number

the nanoseconds within the second, always positive, never exceeds 999,999,999

public plus(amount: TemporalAmount | number, unit: TemporalUnit): Instant source

Params:

NameTypeAttributeDescription
amount TemporalAmount | number
unit TemporalUnit

only required if first param is a TemporalAmount

Return:

Instant

public plus1(amount: TemporalAmount): Instant source

Params:

NameTypeAttributeDescription
amount TemporalAmount
  • nullable: false

Return:

Instant

Throw:

*

DateTimeException

*

ArithmeticException

public plus2(amountToAdd: number, unit: TemporalUnit): Instant source

Params:

NameTypeAttributeDescription
amountToAdd number
  • nullable: false
unit TemporalUnit
  • nullable: false

Return:

Instant

Throw:

*

DateTimeException

*

ArithmeticException

public plusMillis(millisToAdd: number): Instant source

Returns a copy of this instant with the specified duration in milliseconds added.

This instance is immutable and unaffected by this method call.

Params:

NameTypeAttributeDescription
millisToAdd number

the milliseconds to add, positive or negative

Return:

Instant

an Instant based on this instant with the specified milliseconds added, not null

Throw:

*

DateTimeException if the result exceeds the maximum or minimum instant

*

ArithmeticException if numeric overflow occurs

public plusNanos(nanosToAdd: number): Instant source

Returns a copy of this instant with the specified duration in nanoseconds added.

This instance is immutable and unaffected by this method call.

Params:

NameTypeAttributeDescription
nanosToAdd number

the nanoseconds to add, positive or negative

Return:

Instant

an Instant based on this instant with the specified nanoseconds added, not null

Throw:

*

DateTimeException if the result exceeds the maximum or minimum instant

public plusSeconds(secondsToAdd: number): Instant source

Returns a copy of this instant with the specified duration in seconds added.

This instance is immutable and unaffected by this method call.

Params:

NameTypeAttributeDescription
secondsToAdd number

the seconds to add, positive or negative

Return:

Instant

an Instant based on this instant with the specified seconds added, not null

Throw:

*

DateTimeException if the result exceeds the maximum or minimum instant

public query(query: TemporalQuery): * source

Queries this instant using the specified query.

This queries this instant using the specified query strategy object. The TemporalQuery object defines the logic to be used to obtain the result. Read the documentation of the query to understand what the result of this method will be.

The result of this method is obtained by invoking the TemporalQuery#queryFrom method on the specified query passing this as the argument.

Override:

TemporalAccessor#query

Params:

NameTypeAttributeDescription
query TemporalQuery
  • nullable: false

the query to invoke, not null

Return:

*

the query result, null may be returned (defined by the query)

Throw:

*

DateTimeException if unable to query (defined by the query)

*

ArithmeticException if numeric overflow occurs (defined by the query)

public range(field: TemporalField): ValueRange source

Gets the range of valid values for the specified field.

The range object expresses the minimum and maximum valid values for a field. This instant is used to enhance the accuracy of the returned range. If it is not possible to return the range, because the field is not supported or for some other reason, an exception is thrown.

If the field is a ChronoField then the query is implemented here. The supported fields (see isSupported) will return appropriate range instances. All other ChronoField instances will throw a DateTimeException.

If the field is not a ChronoField, then the result of this method is obtained by invoking TemporalField.rangeRefinedBy passing this as the argument. Whether the range can be obtained is determined by the field.

Override:

TemporalAccessor#range

Params:

NameTypeAttributeDescription
field TemporalField

the field to query the range for, not null

Return:

ValueRange

the range of valid values for the field, not null

Throw:

*

DateTimeException if the range for the field cannot be obtained

public toEpochMilli(): number source

Converts this instant to the number of milliseconds from the epoch of 1970-01-01T00:00:00Z.

If this instant represents a point on the time-line too far in the future or past to fit in a long milliseconds, then an exception is thrown.

If this instant has greater than millisecond precision, then the conversion will drop any excess precision information as though the amount in nanoseconds was subject to integer division by one million.

Return:

number

the number of milliseconds since the epoch of 1970-01-01T00:00:00Z

Throw:

*

ArithmeticException if numeric overflow occurs

public toJSON(): string source

Return:

string

same as LocalDate.toString

public toString(): string source

A string representation of this instant using ISO-8601 representation.

The format used is the same as DateTimeFormatter#ISO_INSTANT.

Return:

string

an ISO-8601 representation of this instant, not null

public truncatedTo(unit: TemporalUnit): Instant source

Returns a copy of this Instant truncated to the specified unit.

Truncating the instant returns a copy of the original with fields smaller than the specified unit set to zero. The fields are calculated on the basis of using a UTC offset as seen in toString. For example, truncating with ChronoUnit#MINUTES will round down to the nearest minute, setting the seconds and nanoseconds to zero.

The unit must have a duration (see TemporalUnit#getDuration) that divides into the length of a standard day without remainder. This includes all supplied time units on ChronoUnit and ChronoUnit#DAYS. Other units throw an exception.

This instance is immutable and unaffected by this method call.

Params:

NameTypeAttributeDescription
unit TemporalUnit
  • nullable: false

the unit to truncate to, not null

Return:

Instant

an Instant based on this instant with the time truncated, not null

Throw:

*

DateTimeException if the unit is invalid for truncation

public until(endExclusive: Temporal, unit: TemporalUnit): number source

Calculates the period between this instant and another instant in terms of the specified unit.

This calculates the period between two instants in terms of a single unit. The start and end points are this and the specified instant. The result will be negative if the end is before the start. The calculation returns a whole number, representing the number of complete units between the two instants. The Temporal passed to this method is converted to a Instant using from. For example, the period in days between two dates can be calculated using startInstant.until(endInstant, SECONDS).

This method operates in association with TemporalUnit#between. The result of this method is a long representing the amount of the specified unit. By contrast, the result of between is an object that can be used directly in addition/subtraction:

  long period = start.until(end, SECONDS);   // this method
  dateTime.plus(SECONDS.between(start, end));      // use in plus/minus

The calculation is implemented in this method for ChronoUnit. The units NANOS, MICROS, MILLIS, SECONDS, MINUTES, HOURS, HALF_DAYS and DAYS are supported. Other ChronoUnit values will throw an exception.

If the unit is not a ChronoUnit, then the result of this method is obtained by invoking TemporalUnit.between passing this as the first argument and the input temporal as the second argument.

This instance is immutable and unaffected by this method call.

Params:

NameTypeAttributeDescription
endExclusive Temporal

the end date, which is converted to an Instant, not null

unit TemporalUnit

the unit to measure the period in, not null

Return:

number

the amount of the period between this date and the end date

Throw:

*

DateTimeException if the period cannot be calculated

*

ArithmeticException if numeric overflow occurs

public with(adjusterOrField: TemporalAdjuster | TemporalField, newValue: number): Instant source

function overloading for Instant.with

if called with 1 argument Instant.withTemporalAdjuster is called otherwise Instant.with2

Params:

NameTypeAttributeDescription
adjusterOrField TemporalAdjuster | TemporalField
  • nullable: false
newValue number

Return:

Instant

public with2(field: TemporalField, newValue: number): Instant source

Returns a copy of this instant with the specified field set to a new value.

This returns a new Instant, based on this one, with the value for the specified field changed. If it is not possible to set the value, because the field is not supported or for some other reason, an exception is thrown.

If the field is a ChronoField then the adjustment is implemented here. The supported fields behave as follows:

  • NANO_OF_SECOND - Returns an Instant with the specified nano-of-second. The epoch-second will be unchanged.
  • MICRO_OF_SECOND - Returns an Instant with the nano-of-second replaced by the specified micro-of-second multiplied by 1,000. The epoch-second will be unchanged.
  • MILLI_OF_SECOND - Returns an Instant with the nano-of-second replaced by the specified milli-of-second multiplied by 1,000,000. The epoch-second will be unchanged.
  • INSTANT_SECONDS - Returns an Instant with the specified epoch-second. The nano-of-second will be unchanged.

In all cases, if the new value is outside the valid range of values for the field then a DateTimeException will be thrown.

All other ChronoField instances will throw a DateTimeException.

If the field is not a ChronoField, then the result of this method is obtained by invoking TemporalField.adjustInto passing this as the argument. In this case, the field determines whether and how to adjust the instant.

This instance is immutable and unaffected by this method call.

Params:

NameTypeAttributeDescription
field TemporalField

the field to set in the result, not null

newValue number

the new value of the field in the result

Return:

Instant

an Instant based on this with the specified field set, not null

Throw:

*

DateTimeException if the field cannot be set

*

ArithmeticException if numeric overflow occurs

public withTemporalAdjuster(adjuster: TemporalAdjuster): Instant source

Returns an adjusted copy of this instant.

This returns a new Instant, based on this one, with the date adjusted. The adjustment takes place using the specified adjuster strategy object. Read the documentation of the adjuster to understand what adjustment will be made.

The result of this method is obtained by invoking the TemporalAdjuster#adjustInto method on the specified adjuster passing this as the argument.

This instance is immutable and unaffected by this method call.

Params:

NameTypeAttributeDescription
adjuster TemporalAdjuster
  • nullable: false

the adjuster to use, not null

Return:

Instant

an Instant based on this with the adjustment made, not null

Throw:

*

DateTimeException if the adjustment cannot be made

*

ArithmeticException if numeric overflow occurs