LocalTime (ThreeTen Date and Time API)

java.lang.Object
- javax.time.LocalTime

All Implemented Interfaces:

java.io.Serializable, java.lang.Comparable<LocalTime>, Temporal, Temporal.WithAdjuster, TemporalAccessor
```
public final class LocalTime
extends java.lang.Object
implements Temporal, Temporal.WithAdjuster, java.lang.Comparable<LocalTime>, java.io.Serializable
```
A time without time-zone in the ISO-8601 calendar system, such as 10:15:30.
LocalTime is an immutable date-time object that represents a time, often viewed as hour-minute-second.
This class stores all time fields, to a precision of nanoseconds. It does not store or represent a date or time-zone. For example, the value "13:45.30.123456789" can be stored in a LocalTime.
Implementation notes
This class is immutable and thread-safe.

See Also:
Serialized Form

Nested Class Summary
- Nested classes/interfaces inherited from interface javax.time.temporal.Temporal
  Temporal.MinusAdjuster, Temporal.PlusAdjuster, Temporal.WithAdjuster
- Nested classes/interfaces inherited from interface javax.time.temporal.TemporalAccessor
  TemporalAccessor.Query<R>

Field Summary

Fields
Modifier and Type	Field and Description
`static LocalTime`	`MAX_TIME` Constant for the local time just before midnight, 23:59:59.999999999.
`static LocalTime`	`MIDNIGHT` Constant for the local time of midnight, 00:00.
`static LocalTime`	`MIN_TIME` Constant for the local time of midnight, 00:00.
`static LocalTime`	`NOON` Constant for the local time of noon, 12:00.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`LocalDateTime`	`atDate(LocalDate date)` Returns a local date-time formed from this time at the specified date.
`OffsetTime`	`atOffset(ZoneOffset offset)` Returns an offset time formed from this time and the specified offset.
`int`	`compareTo(LocalTime other)` Compares this `LocalTime` to another time.
`Temporal`	`doWithAdjustment(Temporal temporal)` Implementation of the strategy to make an adjustment to the specified temporal object.
`boolean`	`equals(java.lang.Object obj)` Checks if this time is equal to another time.
`static LocalTime`	`from(TemporalAccessor temporal)` Obtains an instance of `LocalTime` from a temporal object.
`int`	`get(TemporalField field)` Gets the value of the specified field as an `int`.
`int`	`getHour()` Gets the hour-of-day field.
`long`	`getLong(TemporalField field)` Gets the value of the specified field as a `Long`.
`int`	`getMinute()` Gets the minute-of-hour field.
`int`	`getNano()` Gets the nano-of-second field.
`int`	`getSecond()` Gets the second-of-minute field.
`int`	`hashCode()` A hash code for this time.
`boolean`	`isAfter(LocalTime other)` Checks if this `LocalTime` is after the specified time.
`boolean`	`isBefore(LocalTime other)` Checks if this `LocalTime` is before the specified time.
`boolean`	`isSupported(TemporalField field)` Checks if the specified field is supported.
`LocalTime`	`minus(long amountToSubtract, TemporalUnit unit)` Returns a copy of this time with the specified period subtracted.
`LocalTime`	`minus(Temporal.MinusAdjuster adjuster)` Returns a copy of this time with the specified period subtracted.
`LocalTime`	`minusHours(long hoursToSubtract)` Returns a copy of this `LocalTime` with the specified period in hours subtracted.
`LocalTime`	`minusMinutes(long minutesToSubtract)` Returns a copy of this `LocalTime` with the specified period in minutes subtracted.
`LocalTime`	`minusNanos(long nanosToSubtract)` Returns a copy of this `LocalTime` with the specified period in nanoseconds subtracted.
`LocalTime`	`minusSeconds(long secondsToSubtract)` Returns a copy of this `LocalTime` with the specified period in seconds subtracted.
`static LocalTime`	`now()` Obtains the current time from the system clock in the default time-zone.
`static LocalTime`	`now(Clock clock)` Obtains the current time from the specified clock.
`static LocalTime`	`now(ZoneId zone)` Obtains the current time from the system clock in the specified time-zone.
`static LocalTime`	`of(int hour, int minute)` Obtains an instance of `LocalTime` from an hour and minute.
`static LocalTime`	`of(int hour, int minute, int second)` Obtains an instance of `LocalTime` from an hour, minute and second.
`static LocalTime`	`of(int hour, int minute, int second, int nanoOfSecond)` Obtains an instance of `LocalTime` from an hour, minute, second and nanosecond.
`static LocalTime`	`ofNanoOfDay(long nanoOfDay)` Obtains an instance of `LocalTime` from a nanos-of-day value.
`static LocalTime`	`ofSecondOfDay(long secondOfDay)` Obtains an instance of `LocalTime` from a second-of-day value.
`static LocalTime`	`ofSecondOfDay(long secondOfDay, int nanoOfSecond)` Obtains an instance of `LocalTime` from a second-of-day value, with associated nanos of second.
`static LocalTime`	`parse(java.lang.CharSequence text)` Obtains an instance of `LocalTime` from a text string such as `10:15`.
`static LocalTime`	`parse(java.lang.CharSequence text, DateTimeFormatter formatter)` Obtains an instance of `LocalTime` from a text string using a specific formatter.
`long`	`periodUntil(Temporal endDateTime, TemporalUnit unit)` Calculates the period from this date-time until the given date-time in the specified unit.
`LocalTime`	`plus(long amountToAdd, TemporalUnit unit)` Returns a copy of this time with the specified period added.
`LocalTime`	`plus(Temporal.PlusAdjuster adjuster)` Returns a copy of this date with the specified period added.
`LocalTime`	`plusHours(long hoursToAdd)` Returns a copy of this `LocalTime` with the specified period in hours added.
`LocalTime`	`plusMinutes(long minutesToAdd)` Returns a copy of this `LocalTime` with the specified period in minutes added.
`LocalTime`	`plusNanos(long nanosToAdd)` Returns a copy of this `LocalTime` with the specified period in nanoseconds added.
`LocalTime`	`plusSeconds(long secondstoAdd)` Returns a copy of this `LocalTime` with the specified period in seconds added.
`<R> R`	`query(TemporalAccessor.Query<R> query)` Queries this date-time.
`ValueRange`	`range(TemporalField field)` Gets the range of valid values for the specified field.
`long`	`toNanoOfDay()` Extracts the time as nanos of day, from `0` to `24 * 60 * 60 * 1,000,000,000 - 1`.
`int`	`toSecondOfDay()` Extracts the time as seconds of day, from `0` to `24 * 60 * 60 - 1`.
`java.lang.String`	`toString()` Outputs this time as a `String`, such as `10:15`.
`java.lang.String`	`toString(DateTimeFormatter formatter)` Outputs this time as a `String` using the formatter.
`LocalTime`	`truncatedTo(TemporalUnit unit)` Returns a copy of this `LocalTime` with the time truncated.
`LocalTime`	`with(Temporal.WithAdjuster adjuster)` Returns an adjusted time based on this time.
`LocalTime`	`with(TemporalField field, long newValue)` Returns a copy of this time with the specified field altered.
`LocalTime`	`withHour(int hour)` Returns a copy of this `LocalTime` with the hour-of-day value altered.
`LocalTime`	`withMinute(int minute)` Returns a copy of this `LocalTime` with the minute-of-hour value altered.
`LocalTime`	`withNano(int nanoOfSecond)` Returns a copy of this `LocalTime` with the nano-of-second value altered.
`LocalTime`	`withSecond(int second)` Returns a copy of this `LocalTime` with the second-of-minute value altered.

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Field Detail
  - MIN_TIME
```
public static final LocalTime MIN_TIME
```
    Constant for the local time of midnight, 00:00.
  - MAX_TIME
```
public static final LocalTime MAX_TIME
```
    Constant for the local time just before midnight, 23:59:59.999999999.
  - MIDNIGHT
```
public static final LocalTime MIDNIGHT
```
    Constant for the local time of midnight, 00:00.
  - NOON
```
public static final LocalTime NOON
```
    Constant for the local time of noon, 12:00.
- Method Detail
  - now
```
public static LocalTime now()
```
    Obtains the current time from the system clock in the default time-zone.
    This will query the system clock in the default time-zone to obtain the current time.
    Using this method will prevent the ability to use an alternate clock for testing because the clock is hard-coded.
    
    Returns:
    the current time using the system clock and default time-zone, not null
  - now
```
public static LocalTime now(ZoneId zone)
```
    Obtains the current time from the system clock in the specified time-zone.
    This will query the system clock to obtain the current time. Specifying the time-zone avoids dependence on the default time-zone.
    Using this method will prevent the ability to use an alternate clock for testing because the clock is hard-coded.
    
    Returns:
    the current time using the system clock, not null
  - now
```
public static LocalTime now(Clock clock)
```
    Obtains the current time from the specified clock.
    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 dependency injection.
    
    Parameters:
    clock - the clock to use, not null
    
    Returns:
    the current time, not null
  - of
```
public static LocalTime of(int hour,
           int minute)
```
    Obtains an instance of LocalTime from an hour and minute.
    The second and nanosecond fields will be set to zero by this factory method.
    This factory may return a cached value, but applications must not rely on this.
    
    Parameters:
    hour - the hour-of-day to represent, from 0 to 23
    minute - the minute-of-hour to represent, from 0 to 59
    
    Returns:
    the local time, not null
    
    Throws:
    
    DateTimeException - if the value of any field is out of range
  - of
```
public static LocalTime of(int hour,
           int minute,
           int second)
```
    Obtains an instance of LocalTime from an hour, minute and second.
    The nanosecond field will be set to zero by this factory method.
    This factory may return a cached value, but applications must not rely on this.
    
    Parameters:
    hour - the hour-of-day to represent, from 0 to 23
    minute - the minute-of-hour to represent, from 0 to 59
    second - the second-of-minute to represent, from 0 to 59
    
    Returns:
    the local time, not null
    
    Throws:
    
    DateTimeException - if the value of any field is out of range
  - of
```
public static LocalTime of(int hour,
           int minute,
           int second,
           int nanoOfSecond)
```
    Obtains an instance of LocalTime from an hour, minute, second and nanosecond.
    This factory may return a cached value, but applications must not rely on this.
    
    Parameters:
    hour - the hour-of-day to represent, from 0 to 23
    minute - the minute-of-hour to represent, from 0 to 59
    second - the second-of-minute to represent, from 0 to 59
    nanoOfSecond - the nano-of-second to represent, from 0 to 999,999,999
    
    Returns:
    the local time, not null
    
    Throws:
    
    DateTimeException - if the value of any field is out of range
  - ofSecondOfDay
```
public static LocalTime ofSecondOfDay(long secondOfDay)
```
    Obtains an instance of LocalTime from a second-of-day value.
    This factory may return a cached value, but applications must not rely on this.
    
    Parameters:
    secondOfDay - the second-of-day, from 0 to 24 * 60 * 60 - 1
    
    Returns:
    the local time, not null
    
    Throws:
    
    DateTimeException - if the second-of-day value is invalid
  - ofSecondOfDay
```
public static LocalTime ofSecondOfDay(long secondOfDay,
                      int nanoOfSecond)
```
    Obtains an instance of LocalTime from a second-of-day value, with associated nanos of second.
    This factory may return a cached value, but applications must not rely on this.
    
    Parameters:
    secondOfDay - the second-of-day, from 0 to 24 * 60 * 60 - 1
    nanoOfSecond - the nano-of-second, from 0 to 999,999,999
    
    Returns:
    the local time, not null
    
    Throws:
    
    DateTimeException - if the either input value is invalid
  - ofNanoOfDay
```
public static LocalTime ofNanoOfDay(long nanoOfDay)
```
    Obtains an instance of LocalTime from a nanos-of-day value.
    This factory may return a cached value, but applications must not rely on this.
    
    Parameters:
    nanoOfDay - the nano of day, from 0 to 24 * 60 * 60 * 1,000,000,000 - 1
    
    Returns:
    the local time, not null
    
    Throws:
    
    DateTimeException - if the nanos of day value is invalid
  - from
```
public static LocalTime from(TemporalAccessor temporal)
```
    Obtains an instance of LocalTime 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 LocalTime.
    The conversion extracts the nano-of-day field.
    
    Parameters:
    temporal - the temporal object to convert, not null
    
    Returns:
    the local time, not null
    
    Throws:
    
    DateTimeException - if unable to convert to a LocalTime
  - parse
```
public static LocalTime parse(java.lang.CharSequence text)
```
    Obtains an instance of LocalTime from a text string such as 10:15.
    The string must represent a valid time and is parsed using DateTimeFormatters.isoLocalTime().
    
    Parameters:
    text - the text to parse such as "10:15:30", not null
    
    Returns:
    the parsed local time, not null
    
    Throws:
    
    DateTimeParseException - if the text cannot be parsed
  - parse
```
public static LocalTime parse(java.lang.CharSequence text,
              DateTimeFormatter formatter)
```
    Obtains an instance of LocalTime from a text string using a specific formatter.
    The text is parsed using the formatter, returning a time.
    
    Parameters:
    text - the text to parse, not null
    formatter - the formatter to use, not null
    
    Returns:
    the parsed local time, not null
    
    Throws:
    
    DateTimeParseException - if the text cannot be parsed
  - isSupported
```
public boolean isSupported(TemporalField field)
```
    Description copied from interface: TemporalAccessor
    
    Checks if the specified field is supported.
    This checks if the date-time can be queried for the specified field. If false, then calling the range and get methods will throw an exception.
    Implementation notes
    Implementations must check and handle any fields defined in ChronoField before delegating on to the doRange method on the specified field.
    
    Specified by:
    
    isSupported in interface TemporalAccessor
    
    Parameters:
    field - the field to check, null returns false
    
    Returns:
    true if this date-time can be queried for the field, false if not
  - range
```
public ValueRange range(TemporalField field)
```
    Description copied from interface: TemporalAccessor
    
    Gets the range of valid values for the specified field.
    All fields can be expressed as a long integer. This method returns an object that describes the valid range for that value. If the date-time cannot return the range, because the field is unsupported or for some other reason, an exception will be thrown.
    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.
    Implementation notes
    Implementations must check and handle any fields defined in ChronoField before delegating on to the doRange method on the specified field.
    This default implementation checks the field to determine if it is a ChronoField. If the field is, then if it is supported the TemporalField.range() method is used, otherwise an exception is thrown. If it is not a ChronoField then TemporalField.doRange(TemporalAccessor) is called.
    
    Specified by:
    
    range in interface TemporalAccessor
    
    Parameters:
    field - the field to get, not null
    
    Returns:
    the range of valid values for the field, not null
  - get
```
public int get(TemporalField field)
```
    Description copied from interface: TemporalAccessor
    
    Gets the value of the specified field as an int.
    This queries the date-time for the value for the specified field. The returned value will always be within the valid range of values for the field. If the date-time cannot return the value, because the field is unsupported or for some other reason, an exception will be thrown.
    Implementation notes
    Implementations must check and handle any fields defined in ChronoField before delegating on to the doGet method on the specified field.
    This default implementation uses TemporalAccessor.getLong(TemporalField) to find the value and TemporalAccessor.range(TemporalField) to validate it.
    
    Specified by:
    
    get in interface TemporalAccessor
    
    Parameters:
    field - the field to get, not null
    
    Returns:
    the value for the field
  - getLong
```
public long getLong(TemporalField field)
```
    Description copied from interface: TemporalAccessor
    
    Gets the value of the specified field as a Long.
    This queries the date-time for the value for the specified field. The returned value may be outside the valid range of values for the field. If the date-time cannot return the value, because the field is unsupported or for some other reason, an exception will be thrown.
    Implementation notes
    Implementations must check and handle any fields defined in ChronoField before delegating on to the doGet method on the specified field.
    
    Specified by:
    
    getLong in interface TemporalAccessor
    
    Parameters:
    field - the field to get, not null
    
    Returns:
    the value for the field
  - getHour
```
public int getHour()
```
    Gets the hour-of-day field.
    
    Returns:
    the hour-of-day, from 0 to 23
  - getMinute
```
public int getMinute()
```
    Gets the minute-of-hour field.
    
    Returns:
    the minute-of-hour, from 0 to 59
  - getSecond
```
public int getSecond()
```
    Gets the second-of-minute field.
    
    Returns:
    the second-of-minute, from 0 to 59
  - getNano
```
public int getNano()
```
    Gets the nano-of-second field.
    
    Returns:
    the nano-of-second, from 0 to 999,999,999
  - with
```
public LocalTime with(Temporal.WithAdjuster adjuster)
```
    Returns an adjusted time based on this time.
    This adjusts the time according to the rules of the specified adjuster. 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. The adjuster is responsible for handling special cases, such as the varying lengths of month and leap years.
    For example, were there to be a class AmPm implementing the adjuster interface then this method could be used to change the AM/PM value.
    This instance is immutable and unaffected by this method call.
    
    Specified by:
    
    with in interface Temporal
    
    Parameters:
    adjuster - the adjuster to use, not null
    
    Returns:
    a LocalTime based on this time with the adjustment made, not null
    
    Throws:
    
    DateTimeException - if the adjustment cannot be made
  - with
```
public LocalTime with(TemporalField field,
             long newValue)
```
    Returns a copy of this time with the specified field altered.
    This method returns a new time based on this time with a new value for the specified field. This can be used to change any field, for example to set the hour-of-day.
    This instance is immutable and unaffected by this method call.
    
    Specified by:
    
    with in interface Temporal
    
    Parameters:
    field - the field to set in the result, not null
    newValue - the new value of the field in the result
    
    Returns:
    a LocalTime based on this time with the specified field set, not null
    
    Throws:
    
    DateTimeException - if the value is invalid
  - withHour
```
public LocalTime withHour(int hour)
```
    Returns a copy of this LocalTime with the hour-of-day value altered.
    This instance is immutable and unaffected by this method call.
    
    Parameters:
    hour - the hour-of-day to set in the result, from 0 to 23
    
    Returns:
    a LocalTime based on this time with the requested hour, not null
    
    Throws:
    
    DateTimeException - if the hour value is invalid
  - withMinute
```
public LocalTime withMinute(int minute)
```
    Returns a copy of this LocalTime with the minute-of-hour value altered.
    This instance is immutable and unaffected by this method call.
    
    Parameters:
    minute - the minute-of-hour to set in the result, from 0 to 59
    
    Returns:
    a LocalTime based on this time with the requested minute, not null
    
    Throws:
    
    DateTimeException - if the minute value is invalid
  - withSecond
```
public LocalTime withSecond(int second)
```
    Returns a copy of this LocalTime with the second-of-minute value altered.
    This instance is immutable and unaffected by this method call.
    
    Parameters:
    second - the second-of-minute to set in the result, from 0 to 59
    
    Returns:
    a LocalTime based on this time with the requested second, not null
    
    Throws:
    
    DateTimeException - if the second value is invalid
  - withNano
```
public LocalTime withNano(int nanoOfSecond)
```
    Returns a copy of this LocalTime with the nano-of-second value altered.
    This instance is immutable and unaffected by this method call.
    
    Parameters:
    nanoOfSecond - the nano-of-second to set in the result, from 0 to 999,999,999
    
    Returns:
    a LocalTime based on this time with the requested nanosecond, not null
    
    Throws:
    
    DateTimeException - if the nanos value is invalid
  - truncatedTo
```
public LocalTime truncatedTo(TemporalUnit unit)
```
    Returns a copy of this LocalTime with the time truncated.
    Truncating the time returns a copy of the original time with fields smaller than the specified unit set to zero. For example, truncating with the minutes unit will set the second-of-minute and nano-of-second field to zero.
    Not all units are accepted. The days unit and time units with an exact duration can be used, other units throw an exception.
    This instance is immutable and unaffected by this method call.
    
    Parameters:
    unit - the unit to truncate to, not null
    
    Returns:
    a LocalTime based on this time with the time truncated, not null
    
    Throws:
    
    DateTimeException - if unable to truncate
  - plus
```
public LocalTime plus(Temporal.PlusAdjuster adjuster)
```
    Returns a copy of this date with the specified period added.
    This method returns a new time based on this time with the specified period added. The adjuster is typically Period but may be any other type implementing the Temporal.PlusAdjuster interface. The calculation is delegated to the specified adjuster, which typically calls back to plus(long, javax.time.temporal.TemporalUnit).
    This instance is immutable and unaffected by this method call.
    
    Specified by:
    
    plus in interface Temporal
    
    Parameters:
    adjuster - the adjuster to use, not null
    
    Returns:
    a LocalTime based on this time with the addition made, not null
    
    Throws:
    
    DateTimeException - if the addition cannot be made
    
    java.lang.ArithmeticException - if numeric overflow occurs
  - plus
```
public LocalTime plus(long amountToAdd,
             TemporalUnit unit)
```
    Returns a copy of this time with the specified period added.
    This method returns a new time based on this time with the specified period added. This can be used to add any period that is defined by a unit, for example to add hours, minutes or seconds. The unit is responsible for the details of the calculation, including the resolution of any edge cases in the calculation.
    This instance is immutable and unaffected by this method call.
    
    Specified by:
    
    plus in interface Temporal
    
    Parameters:
    amountToAdd - the amount of the unit to add to the result, may be negative
    unit - the unit of the period to add, not null
    
    Returns:
    a LocalTime based on this time with the specified period added, not null
    
    Throws:
    
    DateTimeException - if the unit cannot be added to this type
  - plusHours
```
public LocalTime plusHours(long hoursToAdd)
```
    Returns a copy of this LocalTime with the specified period in hours added.
    This adds the specified number of hours to this time, returning a new time. The calculation wraps around midnight.
    This instance is immutable and unaffected by this method call.
    
    Parameters:
    hoursToAdd - the hours to add, may be negative
    
    Returns:
    a LocalTime based on this time with the hours added, not null
  - plusMinutes
```
public LocalTime plusMinutes(long minutesToAdd)
```
    Returns a copy of this LocalTime with the specified period in minutes added.
    This adds the specified number of minutes to this time, returning a new time. The calculation wraps around midnight.
    This instance is immutable and unaffected by this method call.
    
    Parameters:
    minutesToAdd - the minutes to add, may be negative
    
    Returns:
    a LocalTime based on this time with the minutes added, not null
  - plusSeconds
```
public LocalTime plusSeconds(long secondstoAdd)
```
    Returns a copy of this LocalTime with the specified period in seconds added.
    This adds the specified number of seconds to this time, returning a new time. The calculation wraps around midnight.
    This instance is immutable and unaffected by this method call.
    
    Parameters:
    secondstoAdd - the seconds to add, may be negative
    
    Returns:
    a LocalTime based on this time with the seconds added, not null
  - plusNanos
```
public LocalTime plusNanos(long nanosToAdd)
```
    Returns a copy of this LocalTime with the specified period in nanoseconds added.
    This adds the specified number of nanoseconds to this time, returning a new time. The calculation wraps around midnight.
    This instance is immutable and unaffected by this method call.
    
    Parameters:
    nanosToAdd - the nanos to add, may be negative
    
    Returns:
    a LocalTime based on this time with the nanoseconds added, not null
  - minus
```
public LocalTime minus(Temporal.MinusAdjuster adjuster)
```
    Returns a copy of this time with the specified period subtracted.
    This method returns a new time based on this time with the specified period subtracted. The adjuster is typically Period but may be any other type implementing the Temporal.MinusAdjuster interface. The calculation is delegated to the specified adjuster, which typically calls back to minus(long, javax.time.temporal.TemporalUnit).
    This instance is immutable and unaffected by this method call.
    
    Specified by:
    
    minus in interface Temporal
    
    Parameters:
    adjuster - the adjuster to use, not null
    
    Returns:
    a LocalTime based on this time with the subtraction made, not null
    
    Throws:
    
    DateTimeException - if the subtraction cannot be made
    
    java.lang.ArithmeticException - if numeric overflow occurs
  - minus
```
public LocalTime minus(long amountToSubtract,
              TemporalUnit unit)
```
    Returns a copy of this time with the specified period subtracted.
    This method returns a new time based on this time with the specified period subtracted. This can be used to subtract any period that is defined by a unit, for example to subtract hours, minutes or seconds. The unit is responsible for the details of the calculation, including the resolution of any edge cases in the calculation.
    This instance is immutable and unaffected by this method call.
    
    Specified by:
    
    minus in interface Temporal
    
    Parameters:
    amountToSubtract - the amount of the unit to subtract from the result, may be negative
    unit - the unit of the period to subtract, not null
    
    Returns:
    a LocalTime based on this time with the specified period subtracted, not null
    
    Throws:
    
    DateTimeException - if the unit cannot be added to this type
  - minusHours
```
public LocalTime minusHours(long hoursToSubtract)
```
    Returns a copy of this LocalTime with the specified period in hours subtracted.
    This subtracts the specified number of hours from this time, returning a new time. The calculation wraps around midnight.
    This instance is immutable and unaffected by this method call.
    
    Parameters:
    hoursToSubtract - the hours to subtract, may be negative
    
    Returns:
    a LocalTime based on this time with the hours subtracted, not null
  - minusMinutes
```
public LocalTime minusMinutes(long minutesToSubtract)
```
    Returns a copy of this LocalTime with the specified period in minutes subtracted.
    This subtracts the specified number of minutes from this time, returning a new time. The calculation wraps around midnight.
    This instance is immutable and unaffected by this method call.
    
    Parameters:
    minutesToSubtract - the minutes to subtract, may be negative
    
    Returns:
    a LocalTime based on this time with the minutes subtracted, not null
  - minusSeconds
```
public LocalTime minusSeconds(long secondsToSubtract)
```
    Returns a copy of this LocalTime with the specified period in seconds subtracted.
    This subtracts the specified number of seconds from this time, returning a new time. The calculation wraps around midnight.
    This instance is immutable and unaffected by this method call.
    
    Parameters:
    secondsToSubtract - the seconds to subtract, may be negative
    
    Returns:
    a LocalTime based on this time with the seconds subtracted, not null
  - minusNanos
```
public LocalTime minusNanos(long nanosToSubtract)
```
    Returns a copy of this LocalTime with the specified period in nanoseconds subtracted.
    This subtracts the specified number of nanoseconds from this time, returning a new time. The calculation wraps around midnight.
    This instance is immutable and unaffected by this method call.
    
    Parameters:
    nanosToSubtract - the nanos to subtract, may be negative
    
    Returns:
    a LocalTime based on this time with the nanoseconds subtracted, not null
  - atDate
```
public LocalDateTime atDate(LocalDate date)
```
    Returns a local date-time formed from this time at the specified date.
    This combines this time with the specified date to form a LocalDateTime. All possible combinations of date and time are valid.
    This instance is immutable and unaffected by this method call.
    
    Parameters:
    date - the date to combine with, not null
    
    Returns:
    the local date-time formed from this time and the specified date, not null
  - atOffset
```
public OffsetTime atOffset(ZoneOffset offset)
```
    Returns an offset time formed from this time and the specified offset.
    This combines this time with the specified offset to form an OffsetTime. All possible combinations of time and offset are valid.
    This instance is immutable and unaffected by this method call.
    
    Parameters:
    offset - the offset to combine with, not null
    
    Returns:
    the offset time formed from this time and the specified offset, not null
  - doWithAdjustment
```
public Temporal doWithAdjustment(Temporal temporal)
```
    Description copied from interface: Temporal.WithAdjuster
    Implementation of the strategy to make an adjustment to the specified temporal object.
    This method is not intended to be called by application code directly. Instead, the Temporal.with(WithAdjuster) method should be used:
```
   dateTime = dateTime.with(adjuster);
 
```
    Implementation notes
    The implementation takes the input object and adjusts it according to an algorithm. For example, it could be used to adjust a date to "next Wednesday".
    Implementations must use the methods on Temporal to make the adjustment. The returned object must have the same observable type as the input object
    The target object must not be altered by this method. Instead, an adjusted copy of the original must be returned. This provides equivalent, safe behavior for immutable and mutable implementations.
    This interface can be used by calendar systems other than ISO. Implementations may choose to document compatibility with other calendar systems, or validate for it by querying the chronology from the input object.
    Specified by:
    
    doWithAdjustment in interface Temporal.WithAdjuster
    
    Parameters:
    temporal - the temporal object to adjust, not null
    
    Returns:
    an object of the same type with the adjustment made, not null
  - periodUntil
```
public long periodUntil(Temporal endDateTime,
               TemporalUnit unit)
```
    Description copied from interface: Temporal
    Calculates the period from this date-time until the given date-time in the specified unit.
    This is used to calculate the period between two date-times. This method operates in association with TemporalUnit.between(R, R). That method returns an object which can be used directly in addition/subtraction whereas this method returns the amount directly:
```
   long period = start.periodUntil(end, MONTHS);          // this method
   long period = MONTHS.between(start, end).getAmount();  // same as above
   dateTime.plus(MONTHS.between(start, end));             // directly add
 
```
    Specified by:
    
    periodUntil in interface Temporal
    
    Parameters:
    endDateTime - the end date-time, of the same type as this object, not null
    unit - the unit to measure the period in, not null
    
    Returns:
    the amount of the period between this and the end
  - query
```
public <R> R query(TemporalAccessor.Query<R> query)
```
    Description copied from interface: TemporalAccessor
    Queries this date-time.
    This queries this date-time using the specified query strategy object. The Query interface defines a number of useful queries. Other queries may be defined by applications.
    Implementation notes
    Queries are used for two purposes - general application specific logic, and providing a way to query those parts of a TemporalAccessor that cannot be returned as a long using a field.
    In use, there is no difference between the two purposes. However, there is a difference in implementation. It is the responsibility of implementations of this method to return a value for the three special constants if applicable.
    The three special predefined constants are TemporalAccessor.Query.ZONE_ID, TemporalAccessor.Query.CHRONO and TemporalAccessor.Query.TIME_PRECISION. Future JDKs are permitted to add further special constants.
    The standard implementation of this method will be similar to the following:
```
   public <R> R query(Query<R> type) {
     // only include an if statement if the implementation can return it
     if (query == Query.ZONE_ID)  return ... // the ZoneId
     if (query == Query.CHRONO)  return ... // the Chrono
     if (query == Query.TIME_PRECISION) return ... // the precision
     // call default method
     return super.query(query);
   }
 
```
    If the implementation class has no zone, chronology or precision, then the class can rely totally on the default implementation.
    This default implementation invokes TemporalAccessor.Query.doQuery(TemporalAccessor).
    Specified by:
    
    query in interface TemporalAccessor
    
    Type Parameters:
    R - the type of the result
    Parameters:
    query - the query to invoke, not null
    
    Returns:
    the query result, null may be returned (defined by the query)
  - toSecondOfDay
```
public int toSecondOfDay()
```
    Extracts the time as seconds of day, from 0 to 24 * 60 * 60 - 1.
    
    Returns:
    the second-of-day equivalent to this time
  - toNanoOfDay
```
public long toNanoOfDay()
```
    Extracts the time as nanos of day, from 0 to 24 * 60 * 60 * 1,000,000,000 - 1.
    
    Returns:
    the nano of day equivalent to this time
  - compareTo
```
public int compareTo(LocalTime other)
```
    Compares this LocalTime to another time.
    The comparison is based on the time-line position of the local times within a day. It is "consistent with equals", as defined by Comparable.
    
    Specified by:
    
    compareTo in interface java.lang.Comparable<LocalTime>
    
    Parameters:
    other - the other time to compare to, not null
    
    Returns:
    the comparator value, negative if less, positive if greater
    
    Throws:
    
    java.lang.NullPointerException - if other is null
  - isAfter
```
public boolean isAfter(LocalTime other)
```
    Checks if this LocalTime is after the specified time.
    The comparison is based on the time-line position of the time within a day.
    
    Parameters:
    other - the other time to compare to, not null
    
    Returns:
    true if this is after the specified time
    
    Throws:
    
    java.lang.NullPointerException - if other is null
  - isBefore
```
public boolean isBefore(LocalTime other)
```
    Checks if this LocalTime is before the specified time.
    The comparison is based on the time-line position of the time within a day.
    
    Parameters:
    other - the other time to compare to, not null
    
    Returns:
    true if this point is before the specified time
    
    Throws:
    
    java.lang.NullPointerException - if other is null
  - equals
```
public boolean equals(java.lang.Object obj)
```
    Checks if this time is equal to another time.
    The comparison is based on the time-line position of the time within a day.
    Only objects of type LocalTime are compared, other types return false. To compare the date of two TemporalAccessor instances, use ChronoField.NANO_OF_DAY as a comparator.
    
    Overrides:
    
    equals in class java.lang.Object
    
    Parameters:
    obj - the object to check, null returns false
    
    Returns:
    true if this is equal to the other time
    See Also:
    Object.hashCode(), HashMap
  - hashCode
```
public int hashCode()
```
    A hash code for this time.
    
    Overrides:
    
    hashCode in class java.lang.Object
    
    Returns:
    a suitable hash code
    See Also:
    Object.equals(java.lang.Object), System.identityHashCode(java.lang.Object)
  - toString
```
public java.lang.String toString()
```
    Outputs this time as a String, such as 10:15.
    The output will be one of the following ISO-8601 formats:
    - HH:mm
    - HH:mm:ss
    - HH:mm:ss.SSS
    - HH:mm:ss.SSSSSS
    - HH:mm:ss.SSSSSSSSS
    The format used will be the shortest that outputs the full value of the time where the omitted parts are implied to be zero.
    Overrides:
    
    toString in class java.lang.Object
    
    Returns:
    a string representation of this time, not null
  - toString
```
public java.lang.String toString(DateTimeFormatter formatter)
```
    Outputs this time as a String using the formatter.
    
    Parameters:
    formatter - the formatter to use, not null
    
    Returns:
    the formatted time string, not null
    
    Throws:
    
    DateTimeException - if an error occurs during printing

Class LocalTime

Implementation notes

Nested Class Summary

Nested classes/interfaces inherited from interface javax.time.temporal.Temporal

Nested classes/interfaces inherited from interface javax.time.temporal.TemporalAccessor

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

MIN_TIME

MAX_TIME

MIDNIGHT

NOON

Method Detail

now

now

now

of

of

of

ofSecondOfDay

ofSecondOfDay

ofNanoOfDay

from

parse

parse

isSupported

Implementation notes

range

Implementation notes

get

Implementation notes

getLong

Implementation notes

getHour

getMinute

getSecond

getNano

with

with

withHour

withMinute

withSecond

withNano

truncatedTo

plus

plus

plusHours

plusMinutes

plusSeconds

plusNanos

minus

minus

minusHours

minusMinutes

minusSeconds

minusNanos

atDate

atOffset

doWithAdjustment

Implementation notes

periodUntil

query

Implementation notes

toSecondOfDay

toNanoOfDay

compareTo

isAfter

isBefore

equals

hashCode

toString

toString