LocalTime

A time without a time-zone _in the ISO-8601 calendar system, such as {@code 10:15:30}. !(p) {@code LocalTime} is an immutable date-time object that represents a time, often viewed as hour-minute-second. Time is represented to nanosecond precision. For example, the value "13:45.30.123456789" can be stored _in a {@code LocalTime}. !(p) This class does not store or represent a date or time-zone. Instead, it is a description of the local time as seen on a wall clock. It cannot represent an instant on the time-line without additional information such as an offset or time-zone. !(p) The ISO-8601 calendar system is the modern civil calendar system used today _in most of the world. This API assumes that all calendar systems use the same representation, this class, for time-of-day.

!(p) This is a <a href="{@docRoot}/java.base/java/lang/doc-files/ValueBased.html">value-based</a> class; use of identity-sensitive operations (including reference equality ({@code ==}), identity hash code, or synchronization) on instances of {@code LocalTime} may have unpredictable results and should be avoided. The {@code equals} method should be used for comparisons.

@implSpec This class is immutable and thread-safe.

@since 1.8

final

class LocalTime : Temporal , TemporalAdjuster , Comparable!(LocalTime) {

static LocalTime MIN();

static LocalTime MAX();

static LocalTime MIDNIGHT();

static LocalTime NOON();

static LocalTime[] HOURS();

enum int HOURS_PER_DAY;

enum int MINUTES_PER_HOUR;

enum int MINUTES_PER_DAY;

enum int SECONDS_PER_MINUTE;

enum int SECONDS_PER_HOUR;

enum int SECONDS_PER_DAY;

enum long MILLIS_PER_DAY;

enum long MICROS_PER_DAY;

enum long NANOS_PER_MILLI;

enum long NANOS_PER_SECOND;

enum long NANOS_PER_MINUTE;

enum long NANOS_PER_HOUR;

enum long NANOS_PER_DAY;

static LocalTime now();

static LocalTime now(ZoneId zone);

static LocalTime now(Clock clock);

static LocalTime of(int hour, int minute);

static LocalTime of(int hour, int minute, int second);

static LocalTime of(int hour, int minute, int second, int nanoOfSecond);

static LocalTime ofInstant(Instant instant, ZoneId zone);

static LocalTime ofSecondOfDay(long secondOfDay);

static LocalTime ofNanoOfDay(long nanoOfDay);

static LocalTime from(TemporalAccessor temporal);

this(int hour, int minute, int second, int nanoOfSecond);

bool isSupported(TemporalField field);

bool isSupported(TemporalUnit unit);

ValueRange range(TemporalField field);

ValueRange super_range(TemporalField field);

int get(TemporalField field);

int super_get(TemporalField field);

long getLong(TemporalField field);

int getHour();

int getMinute();

int getSecond();

int getMillisecond();

int getNano();

LocalTime _with(TemporalAdjuster adjuster);

LocalTime _with(TemporalField field, long newValue);

LocalTime withHour(int hour);

LocalTime withMinute(int minute);

LocalTime withSecond(int second);

LocalTime withNano(int nanoOfSecond);

LocalTime truncatedTo(TemporalUnit unit);

LocalTime plus(TemporalAmount amountToAdd);

LocalTime plus(long amountToAdd, TemporalUnit unit);

LocalTime plusHours(long hoursToAdd);

LocalTime plusMinutes(long minutesToAdd);

LocalTime plusSeconds(long secondstoAdd);

LocalTime plusNanos(long nanosToAdd);

LocalTime minus(TemporalAmount amountToSubtract);

LocalTime minus(long amountToSubtract, TemporalUnit unit);

LocalTime minusHours(long hoursToSubtract);

LocalTime minusMinutes(long minutesToSubtract);

LocalTime minusSeconds(long secondsToSubtract);

LocalTime minusNanos(long nanosToSubtract);

R query(TemporalQuery!(R) query);

Temporal adjustInto(Temporal temporal);

long until(Temporal endExclusive, TemporalUnit unit);

LocalDateTime atDate(LocalDate date);

OffsetTime atOffset(ZoneOffset offset);

int toSecondOfDay();

long toNanoOfDay();

long toEpochSecond(LocalDate date, ZoneOffset offset);

int compareTo(LocalTime other);

int opCmp(LocalTime other);

bool isAfter(LocalTime other);

bool isBefore(LocalTime other);

bool opEquals(Object obj);

size_t toHash();

string toString();

void writeExternal(DataOutput _out);

static LocalTime readExternal(DataInput _in);

}

Constructors

this this(int hour, int minute, int second, int nanoOfSecond): Constructor, previously validated.

Members

Functions

_with LocalTime _with(TemporalAdjuster adjuster): Returns an adjusted copy of this time. !(p) This returns a {@code LocalTime}, based on this one, with the time adjusted. The adjustment takes place using the specified adjuster strategy object. Read the documentation of the adjuster to understand what adjustment will be made. !(p) A simple adjuster might simply set the one of the fields, such as the hour field. A more complex adjuster might set the time to the last hour of the day. !(p) The result of this method is obtained by invoking the {@link TemporalAdjuster#adjustInto(Temporal)} method on the specified adjuster passing {@code this} as the argument. !(p) This instance is immutable and unaffected by this method call.
_with LocalTime _with(TemporalField field, long newValue): Returns a copy of this time with the specified field set to a new value. !(p) This returns a {@code LocalTime}, based on this one, with the value for the specified field changed. This can be used to change any supported field, such as the hour, minute or second. If it is not possible to set the value, because the field is not supported or for some other reason, an exception is thrown. !(p) If the field is a {@link ChronoField} then the adjustment is implemented here. The supported fields behave as follows: !(ul) !(li){@code NANO_OF_SECOND} - Returns a {@code LocalTime} with the specified nano-of-second. The hour, minute and second will be unchanged. !(li){@code NANO_OF_DAY} - Returns a {@code LocalTime} with the specified nano-of-day. This completely replaces the time and is equivalent to {@link #ofNanoOfDay(long)}. !(li){@code MICRO_OF_SECOND} - Returns a {@code LocalTime} with the nano-of-second replaced by the specified micro-of-second multiplied by 1,000. The hour, minute and second will be unchanged. !(li){@code MICRO_OF_DAY} - Returns a {@code LocalTime} with the specified micro-of-day. This completely replaces the time and is equivalent to using {@link #ofNanoOfDay(long)} with the micro-of-day multiplied by 1,000. !(li){@code MILLI_OF_SECOND} - Returns a {@code LocalTime} with the nano-of-second replaced by the specified milli-of-second multiplied by 1,000,000. The hour, minute and second will be unchanged. !(li){@code MILLI_OF_DAY} - Returns a {@code LocalTime} with the specified milli-of-day. This completely replaces the time and is equivalent to using {@link #ofNanoOfDay(long)} with the milli-of-day multiplied by 1,000,000. !(li){@code SECOND_OF_MINUTE} - Returns a {@code LocalTime} with the specified second-of-minute. The hour, minute and nano-of-second will be unchanged. !(li){@code SECOND_OF_DAY} - Returns a {@code LocalTime} with the specified second-of-day. The nano-of-second will be unchanged. !(li){@code MINUTE_OF_HOUR} - Returns a {@code LocalTime} with the specified minute-of-hour. The hour, second-of-minute and nano-of-second will be unchanged. !(li){@code MINUTE_OF_DAY} - Returns a {@code LocalTime} with the specified minute-of-day. The second-of-minute and nano-of-second will be unchanged. !(li){@code HOUR_OF_AMPM} - Returns a {@code LocalTime} with the specified hour-of-am-pm. The AM/PM, minute-of-hour, second-of-minute and nano-of-second will be unchanged. !(li){@code CLOCK_HOUR_OF_AMPM} - Returns a {@code LocalTime} with the specified clock-hour-of-am-pm. The AM/PM, minute-of-hour, second-of-minute and nano-of-second will be unchanged. !(li){@code HOUR_OF_DAY} - Returns a {@code LocalTime} with the specified hour-of-day. The minute-of-hour, second-of-minute and nano-of-second will be unchanged. !(li){@code CLOCK_HOUR_OF_DAY} - Returns a {@code LocalTime} with the specified clock-hour-of-day. The minute-of-hour, second-of-minute and nano-of-second will be unchanged. !(li){@code AMPM_OF_DAY} - Returns a {@code LocalTime} with the specified AM/PM. The hour-of-am-pm, minute-of-hour, second-of-minute and nano-of-second will be unchanged. </ul> !(p) In all cases, if the new value is outside the valid range of values for the field then a {@code DateTimeException} will be thrown. !(p) All other {@code ChronoField} instances will throw an {@code UnsupportedTemporalTypeException}. !(p) If the field is not a {@code ChronoField}, then the result of this method is obtained by invoking {@code TemporalField.adjustInto(Temporal, long)} passing {@code this} as the argument. In this case, the field determines whether and how to adjust the instant. !(p) This instance is immutable and unaffected by this method call.
adjustInto Temporal adjustInto(Temporal temporal): Adjusts the specified temporal object to have the same time as this object. !(p) This returns a temporal object of the same observable type as the input with the time changed to be the same as this. !(p) The adjustment is equivalent to using {@link Temporal#_with(TemporalField, long)} passing {@link ChronoField#NANO_OF_DAY} as the field. !(p) In most cases, it is clearer to reverse the calling pattern by using {@link Temporal#_with(TemporalAdjuster)}: !(pre) // these two lines are equivalent, but the second approach is recommended temporal = thisLocalTime.adjustInto(temporal); temporal = temporal._with(thisLocalTime); </pre> !(p) This instance is immutable and unaffected by this method call.
atDate LocalDateTime atDate(LocalDate date): Combines this time with a date to create a {@code LocalDateTime}. !(p) This returns a {@code LocalDateTime} formed from this time at the specified date. All possible combinations of date and time are valid.
atOffset OffsetTime atOffset(ZoneOffset offset): Combines this time with an offset to create an {@code OffsetTime}. !(p) This returns an {@code OffsetTime} formed from this time at the specified offset. All possible combinations of time and offset are valid.
compareTo int compareTo(LocalTime other): Compares this time to another time. !(p) The comparison is based on the time-line position of the local times within a day. It is "consistent with equals", as defined by {@link Comparable}.
get int get(TemporalField field): Gets the value of the specified field from this time as an {@code int}. !(p) This queries this time for the value of 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. !(p) If the field is a {@link ChronoField} then the query is implemented here. The {@link #isSupported(TemporalField) supported fields} will return valid values based on this time, except {@code NANO_OF_DAY} and {@code MICRO_OF_DAY} which are too large to fit _in an {@code int} and throw an {@code UnsupportedTemporalTypeException}. All other {@code ChronoField} instances will throw an {@code UnsupportedTemporalTypeException}. !(p) If the field is not a {@code ChronoField}, then the result of this method is obtained by invoking {@code TemporalField.getFrom(TemporalAccessor)} passing {@code this} as the argument. Whether the value can be obtained, and what the value represents, is determined by the field.
getHour int getHour(): Gets the hour-of-day field.
getLong long getLong(TemporalField field): Gets the value of the specified field from this time as a {@code long}. !(p) This queries this time for the value of 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. !(p) If the field is a {@link ChronoField} then the query is implemented here. The {@link #isSupported(TemporalField) supported fields} will return valid values based on this time. All other {@code ChronoField} instances will throw an {@code UnsupportedTemporalTypeException}. !(p) If the field is not a {@code ChronoField}, then the result of this method is obtained by invoking {@code TemporalField.getFrom(TemporalAccessor)} passing {@code this} as the argument. Whether the value can be obtained, and what the value represents, is determined by the field.
getMillisecond int getMillisecond(): Undocumented in source. Be warned that the author may not have intended to support it.
getMinute int getMinute(): Gets the minute-of-hour field.
getNano int getNano(): Gets the nano-of-second field.
getSecond int getSecond(): Gets the second-of-minute field.
isAfter bool isAfter(LocalTime other): Checks if this time is after the specified time. !(p) The comparison is based on the time-line position of the time within a day.
isBefore bool isBefore(LocalTime other): Checks if this time is before the specified time. !(p) The comparison is based on the time-line position of the time within a day.
isSupported bool isSupported(TemporalField field): Checks if the specified field is supported. !(p) This checks if this time can be queried for the specified field. If false, then calling the {@link #range(TemporalField) range}, {@link #get(TemporalField) get} and {@link #_with(TemporalField, long)} methods will throw an exception. !(p) If the field is a {@link ChronoField} then the query is implemented here. The supported fields are: !(ul) !(li){@code NANO_OF_SECOND} !(li){@code NANO_OF_DAY} !(li){@code MICRO_OF_SECOND} !(li){@code MICRO_OF_DAY} !(li){@code MILLI_OF_SECOND} !(li){@code MILLI_OF_DAY} !(li){@code SECOND_OF_MINUTE} !(li){@code SECOND_OF_DAY} !(li){@code MINUTE_OF_HOUR} !(li){@code MINUTE_OF_DAY} !(li){@code HOUR_OF_AMPM} !(li){@code CLOCK_HOUR_OF_AMPM} !(li){@code HOUR_OF_DAY} !(li){@code CLOCK_HOUR_OF_DAY} !(li){@code AMPM_OF_DAY} </ul> All other {@code ChronoField} instances will return false. !(p) If the field is not a {@code ChronoField}, then the result of this method is obtained by invoking {@code TemporalField.isSupportedBy(TemporalAccessor)} passing {@code this} as the argument. Whether the field is supported is determined by the field.
isSupported bool isSupported(TemporalUnit unit): Checks if the specified unit is supported. !(p) This checks if the specified unit can be added to, or subtracted from, this time. If false, then calling the {@link #plus(long, TemporalUnit)} and {@link #minus(long, TemporalUnit) minus} methods will throw an exception. !(p) If the unit is a {@link ChronoUnit} then the query is implemented here. The supported units are: !(ul) !(li){@code NANOS} !(li){@code MICROS} !(li){@code MILLIS} !(li){@code SECONDS} !(li){@code MINUTES} !(li){@code HOURS} !(li){@code HALF_DAYS} </ul> All other {@code ChronoUnit} instances will return false. !(p) If the unit is not a {@code ChronoUnit}, then the result of this method is obtained by invoking {@code TemporalUnit.isSupportedBy(Temporal)} passing {@code this} as the argument. Whether the unit is supported is determined by the unit.
minus LocalTime minus(TemporalAmount amountToSubtract): Returns a copy of this time with the specified amount subtracted. !(p) This returns a {@code LocalTime}, based on this one, with the specified amount subtracted. The amount is typically {@link Duration} but may be any other type implementing the {@link TemporalAmount} interface. !(p) The calculation is delegated to the amount object by calling {@link TemporalAmount#subtractFrom(Temporal)}. The amount implementation is free to implement the subtraction _in any way it wishes, however it typically calls back to {@link #minus(long, TemporalUnit)}. Consult the documentation of the amount implementation to determine if it can be successfully subtracted. !(p) This instance is immutable and unaffected by this method call.
minus LocalTime minus(long amountToSubtract, TemporalUnit unit): Returns a copy of this time with the specified amount subtracted. !(p) This returns a {@code LocalTime}, based on this one, with the amount _in terms of the unit subtracted. If it is not possible to subtract the amount, because the unit is not supported or for some other reason, an exception is thrown. !(p) This method is equivalent to {@link #plus(long, TemporalUnit)} with the amount negated. See that method for a full description of how addition, and thus subtraction, works. !(p) This instance is immutable and unaffected by this method call.
minusHours LocalTime minusHours(long hoursToSubtract): Returns a copy of this {@code LocalTime} with the specified number of hours subtracted. !(p) This subtracts the specified number of hours from this time, returning a new time. The calculation wraps around midnight. !(p) This instance is immutable and unaffected by this method call.
minusMinutes LocalTime minusMinutes(long minutesToSubtract): Returns a copy of this {@code LocalTime} with the specified number of minutes subtracted. !(p) This subtracts the specified number of minutes from this time, returning a new time. The calculation wraps around midnight. !(p) This instance is immutable and unaffected by this method call.
minusNanos LocalTime minusNanos(long nanosToSubtract): Returns a copy of this {@code LocalTime} with the specified number of nanoseconds subtracted. !(p) This subtracts the specified number of nanoseconds from this time, returning a new time. The calculation wraps around midnight. !(p) This instance is immutable and unaffected by this method call.
minusSeconds LocalTime minusSeconds(long secondsToSubtract): Returns a copy of this {@code LocalTime} with the specified number of seconds subtracted. !(p) This subtracts the specified number of seconds from this time, returning a new time. The calculation wraps around midnight. !(p) This instance is immutable and unaffected by this method call.
opCmp int opCmp(LocalTime other): Undocumented in source. Be warned that the author may not have intended to support it.
opEquals bool opEquals(Object obj): Checks if this time is equal to another time. !(p) The comparison is based on the time-line position of the time within a day. !(p) Only objects of type {@code LocalTime} are compared, other types return false. To compare the date of two {@code TemporalAccessor} instances, use {@link ChronoField#NANO_OF_DAY} as a comparator.
plus LocalTime plus(TemporalAmount amountToAdd): Returns a copy of this time with the specified amount added. !(p) This returns a {@code LocalTime}, based on this one, with the specified amount added. The amount is typically {@link Duration} but may be any other type implementing the {@link TemporalAmount} interface. !(p) The calculation is delegated to the amount object by calling {@link TemporalAmount#addTo(Temporal)}. The amount implementation is free to implement the addition _in any way it wishes, however it typically calls back to {@link #plus(long, TemporalUnit)}. Consult the documentation of the amount implementation to determine if it can be successfully added. !(p) This instance is immutable and unaffected by this method call.
plus LocalTime plus(long amountToAdd, TemporalUnit unit): Returns a copy of this time with the specified amount added. !(p) This returns a {@code LocalTime}, based on this one, with the amount _in terms of the unit added. If it is not possible to add the amount, because the unit is not supported or for some other reason, an exception is thrown. !(p) If the field is a {@link ChronoUnit} then the addition is implemented here. The supported fields behave as follows: !(ul) !(li){@code NANOS} - Returns a {@code LocalTime} with the specified number of nanoseconds added. This is equivalent to {@link #plusNanos(long)}. !(li){@code MICROS} - Returns a {@code LocalTime} with the specified number of microseconds added. This is equivalent to {@link #plusNanos(long)} with the amount multiplied by 1,000. !(li){@code MILLIS} - Returns a {@code LocalTime} with the specified number of milliseconds added. This is equivalent to {@link #plusNanos(long)} with the amount multiplied by 1,000,000. !(li){@code SECONDS} - Returns a {@code LocalTime} with the specified number of seconds added. This is equivalent to {@link #plusSeconds(long)}. !(li){@code MINUTES} - Returns a {@code LocalTime} with the specified number of minutes added. This is equivalent to {@link #plusMinutes(long)}. !(li){@code HOURS} - Returns a {@code LocalTime} with the specified number of hours added. This is equivalent to {@link #plusHours(long)}. !(li){@code HALF_DAYS} - Returns a {@code LocalTime} with the specified number of half-days added. This is equivalent to {@link #plusHours(long)} with the amount multiplied by 12. </ul> !(p) All other {@code ChronoUnit} instances will throw an {@code UnsupportedTemporalTypeException}. !(p) If the field is not a {@code ChronoUnit}, then the result of this method is obtained by invoking {@code TemporalUnit.addTo(Temporal, long)} passing {@code this} as the argument. In this case, the unit determines whether and how to perform the addition. !(p) This instance is immutable and unaffected by this method call.
plusHours LocalTime plusHours(long hoursToAdd): Returns a copy of this {@code LocalTime} with the specified number of hours added. !(p) This adds the specified number of hours to this time, returning a new time. The calculation wraps around midnight. !(p) This instance is immutable and unaffected by this method call.
plusMinutes LocalTime plusMinutes(long minutesToAdd): Returns a copy of this {@code LocalTime} with the specified number of minutes added. !(p) This adds the specified number of minutes to this time, returning a new time. The calculation wraps around midnight. !(p) This instance is immutable and unaffected by this method call.
plusNanos LocalTime plusNanos(long nanosToAdd): Returns a copy of this {@code LocalTime} with the specified number of nanoseconds added. !(p) This adds the specified number of nanoseconds to this time, returning a new time. The calculation wraps around midnight. !(p) This instance is immutable and unaffected by this method call.
plusSeconds LocalTime plusSeconds(long secondstoAdd): Returns a copy of this {@code LocalTime} with the specified number of seconds added. !(p) This adds the specified number of seconds to this time, returning a new time. The calculation wraps around midnight. !(p) This instance is immutable and unaffected by this method call.
query R query(TemporalQuery!(R) query): Queries this time using the specified query. !(p) This queries this time using the specified query strategy object. The {@code 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. !(p) The result of this method is obtained by invoking the {@link TemporalQuery#queryFrom(TemporalAccessor)} method on the specified query passing {@code this} as the argument.
range ValueRange range(TemporalField field): Gets the range of valid values for the specified field. !(p) The range object expresses the minimum and maximum valid values for a field. This time 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. !(p) If the field is a {@link ChronoField} then the query is implemented here. The {@link #isSupported(TemporalField) supported fields} will return appropriate range instances. All other {@code ChronoField} instances will throw an {@code UnsupportedTemporalTypeException}. !(p) If the field is not a {@code ChronoField}, then the result of this method is obtained by invoking {@code TemporalField.rangeRefinedBy(TemporalAccessor)} passing {@code this} as the argument. Whether the range can be obtained is determined by the field.
super_get int super_get(TemporalField field): Undocumented in source. Be warned that the author may not have intended to support it.
super_range ValueRange super_range(TemporalField field): Undocumented in source. Be warned that the author may not have intended to support it.
toEpochSecond long toEpochSecond(LocalDate date, ZoneOffset offset): Converts this {@code LocalTime} to the number of seconds since the epoch of 1970-01-01T00:00:00Z. !(p) This combines this local time with the specified date and offset to calculate the epoch-second value, which is the number of elapsed seconds from 1970-01-01T00:00:00Z. Instants on the time-line after the epoch are positive, earlier are negative.
toHash size_t toHash(): A hash code for this time.
toNanoOfDay long toNanoOfDay(): Extracts the time as nanos of day, from {@code 0} to {@code 24 * 60 * 60 * 1,000,000,000 - 1}.
toSecondOfDay int toSecondOfDay(): Extracts the time as seconds of day, from {@code 0} to {@code 24 * 60 * 60 - 1}.
toString string toString(): Outputs this time as a {@code string}, such as {@code 10:15}. !(p) The output will be one of the following ISO-8601 formats: !(ul) !(li){@code HH:mm}</li> !(li){@code HH:mm:ss}</li> !(li){@code HH:mm:ss.SSS}</li> !(li){@code HH:mm:ss.SSSSSS}</li> !(li){@code HH:mm:ss.SSSSSSSSS}</li> </ul> The format used will be the shortest that outputs the full value of the time where the omitted parts are implied to be zero.
truncatedTo LocalTime truncatedTo(TemporalUnit unit): Returns a copy of this {@code LocalTime} with the time truncated. !(p) Truncation returns a copy of the original time with fields smaller than the specified unit set to zero. For example, truncating with the {@link ChronoUnit#MINUTES minutes} unit will set the second-of-minute and nano-of-second field to zero. !(p) The unit must have a {@linkplain TemporalUnit#getDuration() duration} that divides into the length of a standard day without remainder. This includes all supplied time units on {@link ChronoUnit} and {@link ChronoUnit#DAYS DAYS}. Other units throw an exception. !(p) This instance is immutable and unaffected by this method call.
until long until(Temporal endExclusive, TemporalUnit unit): Calculates the amount of time until another time _in terms of the specified unit. !(p) This calculates the amount of time between two {@code LocalTime} objects _in terms of a single {@code TemporalUnit}. The start and end points are {@code this} and the specified time. The result will be negative if the end is before the start. The {@code Temporal} passed to this method is converted to a {@code LocalTime} using {@link #from(TemporalAccessor)}. For example, the amount _in hours between two times can be calculated using {@code startTime.until(endTime, HOURS)}. !(p) The calculation returns a whole number, representing the number of complete units between the two times. For example, the amount _in hours between 11:30 and 13:29 will only be one hour as it is one minute short of two hours. !(p) There are two equivalent ways of using this method. The first is to invoke this method. The second is to use {@link TemporalUnit#between(Temporal, Temporal)}: !(pre) // these two lines are equivalent amount = start.until(end, MINUTES); amount = MINUTES.between(start, end); </pre> The choice should be made based on which makes the code more readable. !(p) The calculation is implemented _in this method for {@link ChronoUnit}. The units {@code NANOS}, {@code MICROS}, {@code MILLIS}, {@code SECONDS}, {@code MINUTES}, {@code HOURS} and {@code HALF_DAYS} are supported. Other {@code ChronoUnit} values will throw an exception. !(p) If the unit is not a {@code ChronoUnit}, then the result of this method is obtained by invoking {@code TemporalUnit.between(Temporal, Temporal)} passing {@code this} as the first argument and the converted input temporal as the second argument. !(p) This instance is immutable and unaffected by this method call.
withHour LocalTime withHour(int hour): Returns a copy of this {@code LocalTime} with the hour-of-day altered. !(p) This instance is immutable and unaffected by this method call.
withMinute LocalTime withMinute(int minute): Returns a copy of this {@code LocalTime} with the minute-of-hour altered. !(p) This instance is immutable and unaffected by this method call.
withNano LocalTime withNano(int nanoOfSecond): Returns a copy of this {@code LocalTime} with the nano-of-second altered. !(p) This instance is immutable and unaffected by this method call.
withSecond LocalTime withSecond(int second): Returns a copy of this {@code LocalTime} with the second-of-minute altered. !(p) This instance is immutable and unaffected by this method call.
writeExternal void writeExternal(DataOutput _out): Defend against malicious streams.

Static functions

HOURS LocalTime[] HOURS(): Constants for the local time of each hour.
MAX LocalTime MAX(): The maximum supported {@code LocalTime}, '23:59:59.999999999'. This is the time just before midnight at the end of the day.
MIDNIGHT LocalTime MIDNIGHT(): The time of midnight at the start of the day, '00:00'.
MIN LocalTime MIN(): The minimum supported {@code LocalTime}, '00:00'. This is the time of midnight at the start of the day.
NOON LocalTime NOON(): The time of noon _in the middle of the day, '12:00'.
from LocalTime from(TemporalAccessor temporal): Obtains an instance of {@code LocalTime} from a temporal object. !(p) This obtains a local time based on the specified temporal. A {@code TemporalAccessor} represents an arbitrary set of date and time information, which this factory converts to an instance of {@code LocalTime}. !(p) The conversion uses the {@link TemporalQueries#localTime()} query, which relies on extracting the {@link ChronoField#NANO_OF_DAY NANO_OF_DAY} field. !(p) This method matches the signature of the functional interface {@link TemporalQuery} allowing it to be used as a query via method reference, {@code LocalTime.from}.
now LocalTime now(): Obtains the current time from the system clock _in the default time-zone. !(p) This will query the {@link Clock#systemDefaultZone() system clock} _in the default time-zone to obtain the current time. !(p) Using this method will prevent the ability to use an alternate clock for testing because the clock is hard-coded.
now LocalTime now(ZoneId zone): Obtains the current time from the system clock _in the specified time-zone. !(p) This will query the {@link Clock#system(ZoneId) system clock} to obtain the current time. Specifying the time-zone avoids dependence on the default time-zone. !(p) Using this method will prevent the ability to use an alternate clock for testing because the clock is hard-coded.
now LocalTime now(Clock clock): Obtains the current time from the specified clock. !(p) This will query the specified clock to obtain the current time. Using this method allows the use of an alternate clock for testing. The alternate clock may be introduced using {@link Clock dependency injection}.
of LocalTime of(int hour, int minute): Obtains an instance of {@code LocalTime} from an hour and minute. !(p) This returns a {@code LocalTime} with the specified hour and minute. The second and nanosecond fields will be set to zero.
of LocalTime of(int hour, int minute, int second): Obtains an instance of {@code LocalTime} from an hour, minute and second. !(p) This returns a {@code LocalTime} with the specified hour, minute and second. The nanosecond field will be set to zero.
of LocalTime of(int hour, int minute, int second, int nanoOfSecond): Obtains an instance of {@code LocalTime} from an hour, minute, second and nanosecond. !(p) This returns a {@code LocalTime} with the specified hour, minute, second and nanosecond.
ofInstant LocalTime ofInstant(Instant instant, ZoneId zone): Obtains an instance of {@code LocalTime} from an {@code Instant} and zone ID. !(p) This creates a local time based on the specified instant. First, the offset from UTC/Greenwich is obtained using the zone ID and instant, which is simple as there is only one valid offset for each instant. Then, the instant and offset are used to calculate the local time.
ofNanoOfDay LocalTime ofNanoOfDay(long nanoOfDay): Obtains an instance of {@code LocalTime} from a nanos-of-day value. !(p) This returns a {@code LocalTime} with the specified nanosecond-of-day.
ofSecondOfDay LocalTime ofSecondOfDay(long secondOfDay): Obtains an instance of {@code LocalTime} from a second-of-day value. !(p) This returns a {@code LocalTime} with the specified second-of-day. The nanosecond field will be set to zero.
readExternal LocalTime readExternal(DataInput _in): Undocumented in source. Be warned that the author may not have intended to support it.

Variables

HOURS_PER_DAY enum int HOURS_PER_DAY;: Hours per day.
MICROS_PER_DAY enum long MICROS_PER_DAY;: Microseconds per day.
MILLIS_PER_DAY enum long MILLIS_PER_DAY;: Milliseconds per day.
MINUTES_PER_DAY enum int MINUTES_PER_DAY;: Minutes per day.
MINUTES_PER_HOUR enum int MINUTES_PER_HOUR;: Minutes per hour.
NANOS_PER_DAY enum long NANOS_PER_DAY;: Nanos per day.
NANOS_PER_HOUR enum long NANOS_PER_HOUR;: Nanos per hour.
NANOS_PER_MILLI enum long NANOS_PER_MILLI;: Nanos per millisecond.
NANOS_PER_MINUTE enum long NANOS_PER_MINUTE;: Nanos per minute.
NANOS_PER_SECOND enum long NANOS_PER_SECOND;: Nanos per second.
SECONDS_PER_DAY enum int SECONDS_PER_DAY;: Seconds per day.
SECONDS_PER_HOUR enum int SECONDS_PER_HOUR;: Seconds per hour.
SECONDS_PER_MINUTE enum int SECONDS_PER_MINUTE;: Seconds per minute.

Inherited Members

From Temporal

isSupported bool isSupported(TemporalUnit unit): Checks if the specified unit is supported. !(p) This checks if the specified unit can be added to, or subtracted from, this date-time. If false, then calling the {@link #plus(long, TemporalUnit)} and {@link #minus(long, TemporalUnit) minus} methods will throw an exception.
isSupported bool isSupported(TemporalField field): Undocumented in source.
_with Temporal _with(TemporalAdjuster adjuster): Returns an adjusted object of the same type as this object with the adjustment made. !(p) This adjusts this date-time according to the rules of the specified adjuster. A simple adjuster might simply set the one of the fields, such as the year field. A more complex adjuster might set the date to the last day of the month. A selection of common adjustments is provided _in {@link hunt.time.temporal.TemporalAdjusters TemporalAdjusters}. These include finding the "last day of the month" and "next Wednesday". The adjuster is responsible for handling special cases, such as the varying lengths of month and leap years. !(p) Some example code indicating how and why this method is used: !(pre) date = date._with(Month.JULY); // most key classes implement TemporalAdjuster date = date._with(lastDayOfMonth()); // static import from Adjusters date = date._with(next(WEDNESDAY)); // static import from Adjusters and DayOfWeek </pre>
_with Temporal _with(TemporalField field, long newValue): Returns an object of the same type as this object with the specified field altered. !(p) This returns a new object based on this one with the value for the specified field changed. For example, on a {@code LocalDate}, this could be used to set the year, month or day-of-month. The returned object will have the same observable type as this object. !(p) 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 field 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.
plus Temporal plus(TemporalAmount amount): Returns an object of the same type as this object with an amount added. !(p) This adjusts this temporal, adding according to the rules of the specified amount. The amount is typically a {@link hunt.time.Period} but may be any other type implementing the {@link TemporalAmount} interface, such as {@link hunt.time.Duration}. !(p) Some example code indicating how and why this method is used: !(pre) date = date.plus(period); // add a Period instance date = date.plus(duration); // add a Duration instance date = date.plus(workingDays(6)); // example user-written workingDays method </pre> !(p) Note that calling {@code plus} followed by {@code minus} is not guaranteed to return the same date-time.
plus Temporal plus(long amountToAdd, TemporalUnit unit): Returns an object of the same type as this object with the specified period added. !(p) This method returns a new object based on this one with the specified period added. For example, on a {@code LocalDate}, this could be used to add a number of years, months or days. The returned object will have the same observable type as this object. !(p) In some cases, changing a field is not fully defined. For example, if the target object is a date representing the 31st January, then adding one month would be unclear. In cases like this, the field 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.
minus Temporal minus(TemporalAmount amount): Returns an object of the same type as this object with an amount subtracted. !(p) This adjusts this temporal, subtracting according to the rules of the specified amount. The amount is typically a {@link hunt.time.Period} but may be any other type implementing the {@link TemporalAmount} interface, such as {@link hunt.time.Duration}. !(p) Some example code indicating how and why this method is used: !(pre) date = date.minus(period); // subtract a Period instance date = date.minus(duration); // subtract a Duration instance date = date.minus(workingDays(6)); // example user-written workingDays method </pre> !(p) Note that calling {@code plus} followed by {@code minus} is not guaranteed to return the same date-time.
minus Temporal minus(long amountToSubtract, TemporalUnit unit): Returns an object of the same type as this object with the specified period subtracted. !(p) This method returns a new object based on this one with the specified period subtracted. For example, on a {@code LocalDate}, this could be used to subtract a number of years, months or days. The returned object will have the same observable type as this object. !(p) In some cases, changing a field is not fully defined. For example, if the target object is a date representing the 31st March, then subtracting one month would be unclear. In cases like this, the field 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.
until long until(Temporal endExclusive, TemporalUnit unit): Calculates the amount of time until another temporal _in terms of the specified unit. !(p) This calculates the amount of time between two temporal objects _in terms of a single {@code TemporalUnit}. The start and end points are {@code this} and the specified temporal. The end point is converted to be of the same type as the start point if different. The result will be negative if the end is before the start. For example, the amount _in hours between two temporal objects can be calculated using {@code startTime.until(endTime, HOURS)}. !(p) The calculation returns a whole number, representing the number of complete units between the two temporals. For example, the amount _in hours between the times 11:30 and 13:29 will only be one hour as it is one minute short of two hours. !(p) There are two equivalent ways of using this method. The first is to invoke this method directly. The second is to use {@link TemporalUnit#between(Temporal, Temporal)}: !(pre) // these two lines are equivalent temporal = start.until(end, unit); temporal = unit.between(start, end); </pre> The choice should be made based on which makes the code more readable. !(p) For example, this method allows the number of days between two dates to be calculated: !(pre) long daysBetween = start.until(end, DAYS); // or alternatively long daysBetween = DAYS.between(start, end); </pre>

From TemporalAdjuster

adjustInto Temporal adjustInto(Temporal temporal): Adjusts the specified temporal object. !(p) This adjusts the specified temporal object using the logic encapsulated _in the implementing class. Examples might be an adjuster that sets the date avoiding weekends, or one that sets the date to the last day of the month. !(p) There are two equivalent ways of using this method. The first is to invoke this method directly. The second is to use {@link Temporal#_with(TemporalAdjuster)}: !(pre) // these two lines are equivalent, but the second approach is recommended temporal = thisAdjuster.adjustInto(temporal); temporal = temporal._with(thisAdjuster); </pre> It is recommended to use the second approach, {@code _with(TemporalAdjuster)}, as it is a lot clearer to read _in code.

Meta

Source

See Implementation

hunt time LocalTime classes

LocalTime