javax.time.calendar
Class OffsetTime

java.lang.Object
  extended by javax.time.calendar.OffsetTime
All Implemented Interfaces:
java.io.Serializable, java.lang.Comparable<OffsetTime>, Calendrical, CalendricalMatcher

public final class OffsetTime
extends java.lang.Object
implements Calendrical, CalendricalMatcher, java.lang.Comparable<OffsetTime>, java.io.Serializable

A time with a zone offset from UTC in the ISO-8601 calendar system, such as 10:15:30+01:00.

OffsetTime is an immutable calendrical that represents a time, often viewed as hour-minute-second-offset. This class stores all time fields, to a precision of nanoseconds, as well as a zone offset. For example, the value "13:45.30.123456789+02:00" can be stored in a OffsetTime.

OffsetTime is immutable and thread-safe.

Author:
Michael Nascimento Santos, Stephen Colebourne
See Also:
Serialized Form

Method Summary
 int compareTo(OffsetTime other)
          Compares this OffsetTime to another time based on the UTC equivalent times then local time.
 boolean equalInstant(OffsetTime other)
          Checks if the instant of this OffsetTime is equal to that of the specified time applying both times to a common date.
 boolean equals(java.lang.Object obj)
          Checks if this time is equal to another time.
static OffsetTime from(Calendrical... calendricals)
          Obtains an instance of OffsetTime from a set of calendricals.
<T> T
get(CalendricalRule<T> ruleToDerive)
          Gets the value of the specified calendrical rule.
 int getHourOfDay()
          Gets the hour-of-day field.
 int getMinuteOfHour()
          Gets the minute-of-hour field.
 int getNanoOfSecond()
          Gets the nano-of-second field.
 ZoneOffset getOffset()
          Gets the zone offset representing how far ahead or behind UTC the time is.
 int getSecondOfMinute()
          Gets the second-of-minute field.
 int hashCode()
          A hash code for this time.
 boolean isAfter(OffsetTime other)
          Checks if the instant of this OffsetTime is after that of the specified time applying both times to a common date.
 boolean isBefore(OffsetTime other)
          Checks if the instant of this OffsetTime is before that of the specified time applying both times to a common date.
 boolean matches(CalendricalMatcher matcher)
          Checks whether this OffsetTime matches the specified matcher.
 boolean matchesCalendrical(Calendrical calendrical)
          Checks if the time extracted from the calendrical matches this.
 OffsetTime minus(Duration duration)
          Returns a copy of this OffsetTime with the specified duration subtracted.
 OffsetTime minus(PeriodProvider periodProvider)
          Returns a copy of this OffsetTime with the specified period subtracted.
 OffsetTime minusHours(long hours)
          Returns a copy of this OffsetTime with the specified period in hours subtracted.
 OffsetTime minusMinutes(long minutes)
          Returns a copy of this OffsetTime with the specified period in minutes subtracted.
 OffsetTime minusNanos(long nanos)
          Returns a copy of this OffsetTime with the specified period in nanoseconds subtracted.
 OffsetTime minusSeconds(long seconds)
          Returns a copy of this OffsetTime with the specified period in seconds subtracted.
static OffsetTime now()
          Obtains the current time from the system clock in the default time-zone.
static OffsetTime now(Clock clock)
          Obtains the current time from the specified clock.
static OffsetTime of(int hourOfDay, int minuteOfHour, int secondOfMinute, int nanoOfSecond, ZoneOffset offset)
          Obtains an instance of OffsetTime from an hour, minute, second and nanosecond.
static OffsetTime of(int hourOfDay, int minuteOfHour, int secondOfMinute, ZoneOffset offset)
          Obtains an instance of OffsetTime from an hour, minute and second.
static OffsetTime of(int hourOfDay, int minuteOfHour, ZoneOffset offset)
          Obtains an instance of OffsetTime from an hour and minute.
static OffsetTime of(LocalTime time, ZoneOffset offset)
          Obtains an instance of OffsetTime from a local time and an offset.
static OffsetTime ofInstant(InstantProvider instantProvider, ZoneOffset offset)
          Obtains an instance of OffsetTime from an InstantProvider.
static OffsetTime ofInstantUTC(InstantProvider instantProvider)
          Obtains an instance of OffsetTime from an InstantProvider using the UTC offset.
static OffsetTime parse(java.lang.CharSequence text)
          Obtains an instance of OffsetTime from a text string such as 10:15:30+01:00.
static OffsetTime parse(java.lang.CharSequence text, DateTimeFormatter formatter)
          Obtains an instance of OffsetTime from a text string using a specific formatter.
 OffsetTime plus(Duration duration)
          Returns a copy of this OffsetTime with the specified duration added.
 OffsetTime plus(PeriodProvider periodProvider)
          Returns a copy of this OffsetTime with the specified period added.
 OffsetTime plusHours(long hours)
          Returns a copy of this OffsetTime with the specified period in hours added.
 OffsetTime plusMinutes(long minutes)
          Returns a copy of this OffsetTime with the specified period in minutes added.
 OffsetTime plusNanos(long nanos)
          Returns a copy of this OffsetTime with the specified period in nanoseconds added.
 OffsetTime plusSeconds(long seconds)
          Returns a copy of this OffsetTime with the specified period in seconds added.
static CalendricalRule<OffsetTime> rule()
          Gets the rule for OffsetTime.
 LocalTime toLocalTime()
          Converts this time to a LocalTime.
 java.lang.String toString()
          Outputs this time as a String, such as 10:15:30+01:00.
 java.lang.String toString(DateTimeFormatter formatter)
          Outputs this time as a String using the formatter.
 OffsetTime with(TimeAdjuster adjuster)
          Returns a copy of this OffsetTime with the time altered using the adjuster.
 OffsetTime withHourOfDay(int hourOfDay)
          Returns a copy of this OffsetTime with the hour-of-day value altered.
 OffsetTime withMinuteOfHour(int minuteOfHour)
          Returns a copy of this OffsetTime with the minute-of-hour value altered.
 OffsetTime withNanoOfSecond(int nanoOfSecond)
          Returns a copy of this OffsetTime with the nano-of-second value altered.
 OffsetTime withOffsetSameInstant(ZoneOffset offset)
          Returns a copy of this OffsetTime with the specified offset ensuring that the result is at the same instant on an implied day.
 OffsetTime withOffsetSameLocal(ZoneOffset offset)
          Returns a copy of this OffsetTime with the specified offset ensuring that the result has the same local time.
 OffsetTime withSecondOfMinute(int secondOfMinute)
          Returns a copy of this OffsetTime with the second-of-minute value altered.
 
Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait
 

Method Detail

rule

public static CalendricalRule<OffsetTime> rule()
Gets the rule for OffsetTime.

Returns:
the rule for the time, not null

now

public static OffsetTime 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. The offset will be calculated from the time-zone in the clock.

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 OffsetTime now(Clock clock)
Obtains the current time from the specified clock.

This will query the specified clock to obtain the current time. The offset will be calculated from the time-zone in the clock.

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 OffsetTime of(int hourOfDay,
                            int minuteOfHour,
                            ZoneOffset offset)
Obtains an instance of OffsetTime from an hour and minute.

The second and nanosecond fields will be set to zero by this factory method.

Parameters:
hourOfDay - the hour-of-day to represent, from 0 to 23
minuteOfHour - the minute-of-hour to represent, from 0 to 59
offset - the zone offset, not null
Returns:
the offset time, not null
Throws:
IllegalCalendarFieldValueException - if the value of any field is out of range

of

public static OffsetTime of(int hourOfDay,
                            int minuteOfHour,
                            int secondOfMinute,
                            ZoneOffset offset)
Obtains an instance of OffsetTime from an hour, minute and second.

The second field will be set to zero by this factory method.

Parameters:
hourOfDay - the hour-of-day to represent, from 0 to 23
minuteOfHour - the minute-of-hour to represent, from 0 to 59
secondOfMinute - the second-of-minute to represent, from 0 to 59
offset - the zone offset, not null
Returns:
the offset time, not null
Throws:
IllegalCalendarFieldValueException - if the value of any field is out of range

of

public static OffsetTime of(int hourOfDay,
                            int minuteOfHour,
                            int secondOfMinute,
                            int nanoOfSecond,
                            ZoneOffset offset)
Obtains an instance of OffsetTime from an hour, minute, second and nanosecond.

Parameters:
hourOfDay - the hour-of-day to represent, from 0 to 23
minuteOfHour - the minute-of-hour to represent, from 0 to 59
secondOfMinute - the second-of-minute to represent, from 0 to 59
nanoOfSecond - the nano-of-second to represent, from 0 to 999,999,999
offset - the zone offset, not null
Returns:
the offset time, not null
Throws:
IllegalCalendarFieldValueException - if the value of any field is out of range

of

public static OffsetTime of(LocalTime time,
                            ZoneOffset offset)
Obtains an instance of OffsetTime from a local time and an offset.

Parameters:
time - the local time, not null
offset - the zone offset, not null
Returns:
the offset time, not null

ofInstantUTC

public static OffsetTime ofInstantUTC(InstantProvider instantProvider)
Obtains an instance of OffsetTime from an InstantProvider using the UTC offset.

The date component of the instant is dropped during the conversion. This means that the conversion can never fail due to the instant being out of the valid range of dates.

Parameters:
instantProvider - the instant to convert, not null
Returns:
the offset time in UTC, not null

ofInstant

public static OffsetTime ofInstant(InstantProvider instantProvider,
                                   ZoneOffset offset)
Obtains an instance of OffsetTime from an InstantProvider.

The date component of the instant is dropped during the conversion. This means that the conversion can never fail due to the instant being out of the valid range of dates.

Parameters:
instantProvider - the instant to convert, not null
offset - the zone offset, not null
Returns:
the offset time, not null

from

public static OffsetTime from(Calendrical... calendricals)
Obtains an instance of OffsetTime from a set of calendricals.

A calendrical represents some form of date and time information. This method combines the input calendricals into a time.

Parameters:
calendricals - the calendricals to create a time from, no nulls, not null
Returns:
the offset time, not null
Throws:
CalendricalException - if unable to merge to an offset time

parse

public static OffsetTime parse(java.lang.CharSequence text)
Obtains an instance of OffsetTime from a text string such as 10:15:30+01:00.

The string must represent a valid time and is parsed using DateTimeFormatters.isoOffsetTime(). Hour, minute and offset are required. Seconds and fractional seconds are optional.

Parameters:
text - the text to parse such as "10:15:30+01:00", not null
Returns:
the parsed local time, not null
Throws:
CalendricalParseException - if the text cannot be parsed

parse

public static OffsetTime parse(java.lang.CharSequence text,
                               DateTimeFormatter formatter)
Obtains an instance of OffsetTime 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 offset time, not null
Throws:
java.lang.UnsupportedOperationException - if the formatter cannot parse
CalendricalParseException - if the text cannot be parsed

get

public <T> T get(CalendricalRule<T> ruleToDerive)
Gets the value of the specified calendrical rule.

This method queries the value of the specified calendrical rule. If the value cannot be returned for the rule from this time then null will be returned.

Specified by:
get in interface Calendrical
Parameters:
ruleToDerive - the rule to derive, not null
Returns:
the value for the rule, null if the value cannot be returned

getOffset

public ZoneOffset getOffset()
Gets the zone offset representing how far ahead or behind UTC the time is.

Returns:
the zone offset, not null

withOffsetSameLocal

public OffsetTime withOffsetSameLocal(ZoneOffset offset)
Returns a copy of this OffsetTime with the specified offset ensuring that the result has the same local time.

This method returns an object with the same LocalTime and the specified ZoneOffset. No calculation is needed or performed. For example, if this time represents 10:30+02:00 and the offset specified is +03:00, then this method will return 10:30+03:00.

To take into account the difference between the offsets, and adjust the time fields, use withOffsetSameInstant(javax.time.calendar.ZoneOffset).

This instance is immutable and unaffected by this method call.

Parameters:
offset - the zone offset to change to, not null
Returns:
an OffsetTime based on this time with the requested offset, not null

withOffsetSameInstant

public OffsetTime withOffsetSameInstant(ZoneOffset offset)
Returns a copy of this OffsetTime with the specified offset ensuring that the result is at the same instant on an implied day.

This method returns an object with the specified ZoneOffset and a LocalTime adjusted by the difference between the two offsets. This will result in the old and new objects representing the same instant an an implied day. This is useful for finding the local time in a different offset. For example, if this time represents 10:30+02:00 and the offset specified is +03:00, then this method will return 11:30+03:00.

To change the offset without adjusting the local time use withOffsetSameLocal(javax.time.calendar.ZoneOffset).

This instance is immutable and unaffected by this method call.

Parameters:
offset - the zone offset to change to, not null
Returns:
an OffsetTime based on this time with the requested offset, not null

getHourOfDay

public int getHourOfDay()
Gets the hour-of-day field.

Returns:
the hour-of-day, from 0 to 23

getMinuteOfHour

public int getMinuteOfHour()
Gets the minute-of-hour field.

Returns:
the minute-of-hour, from 0 to 59

getSecondOfMinute

public int getSecondOfMinute()
Gets the second-of-minute field.

Returns:
the second-of-minute, from 0 to 59

getNanoOfSecond

public int getNanoOfSecond()
Gets the nano-of-second field.

Returns:
the nano-of-second, from 0 to 999,999,999

with

public OffsetTime with(TimeAdjuster adjuster)
Returns a copy of this OffsetTime with the time altered using the adjuster.

This adjusts the time according to the rules of the specified adjuster. The offset is not part of the calculation and will be unchanged in the result. Note that LocalTime implements TimeAdjuster, thus this method can be used to change the entire time.

This instance is immutable and unaffected by this method call.

Parameters:
adjuster - the adjuster to use, not null
Returns:
an OffsetTime based on this time adjusted as necessary, not null

withHourOfDay

public OffsetTime withHourOfDay(int hourOfDay)
Returns a copy of this OffsetTime with the hour-of-day value altered.

This instance is immutable and unaffected by this method call.

Parameters:
hourOfDay - the hour-of-day to represent, from 0 to 23
Returns:
an OffsetTime based on this time with the requested hour, not null
Throws:
IllegalCalendarFieldValueException - if the hour value is invalid

withMinuteOfHour

public OffsetTime withMinuteOfHour(int minuteOfHour)
Returns a copy of this OffsetTime with the minute-of-hour value altered.

This instance is immutable and unaffected by this method call.

Parameters:
minuteOfHour - the minute-of-hour to represent, from 0 to 59
Returns:
an OffsetTime based on this time with the requested minute, not null
Throws:
IllegalCalendarFieldValueException - if the minute value is invalid

withSecondOfMinute

public OffsetTime withSecondOfMinute(int secondOfMinute)
Returns a copy of this OffsetTime with the second-of-minute value altered.

This instance is immutable and unaffected by this method call.

Parameters:
secondOfMinute - the second-of-minute to represent, from 0 to 59
Returns:
an OffsetTime based on this time with the requested second, not null
Throws:
IllegalCalendarFieldValueException - if the second value is invalid

withNanoOfSecond

public OffsetTime withNanoOfSecond(int nanoOfSecond)
Returns a copy of this OffsetTime with the nano-of-second value altered.

This instance is immutable and unaffected by this method call.

Parameters:
nanoOfSecond - the nano-of-second to represent, from 0 to 999,999,999
Returns:
an OffsetTime based on this time with the requested nanosecond, not null
Throws:
IllegalCalendarFieldValueException - if the nanos value is invalid

plus

public OffsetTime plus(PeriodProvider periodProvider)
Returns a copy of this OffsetTime with the specified period added.

This adds the specified period to this time, returning a new time. The calculation wraps around midnight and ignores any date-based ISO fields.

The period is interpreted using rules equivalent to Period.ofTimeFields(PeriodProvider). Those rules ignore any date-based ISO fields, thus adding a date-based period to this time will have no effect.

This instance is immutable and unaffected by this method call.

Parameters:
periodProvider - the period to add, not null
Returns:
an OffsetTime based on this time with the period added, not null
Throws:
CalendricalException - if the specified period cannot be converted to a Period
java.lang.ArithmeticException - if the period overflows during conversion to hours/minutes/seconds/nanos

plus

public OffsetTime plus(Duration duration)
Returns a copy of this OffsetTime with the specified duration added.

This adds the specified duration to this time, returning a new time. The calculation wraps around midnight.

The calculation is equivalent to using plusSeconds(long) and plusNanos(long) on the two parts of the duration.

This instance is immutable and unaffected by this method call.

Parameters:
duration - the duration to add, not null
Returns:
an OffsetTime based on this time with the duration added, not null

plusHours

public OffsetTime plusHours(long hours)
Returns a copy of this OffsetTime 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:
hours - the hours to add, may be negative
Returns:
an OffsetTime based on this time with the hours added, not null

plusMinutes

public OffsetTime plusMinutes(long minutes)
Returns a copy of this OffsetTime 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:
minutes - the minutes to add, may be negative
Returns:
an OffsetTime based on this time with the minutes added, not null

plusSeconds

public OffsetTime plusSeconds(long seconds)
Returns a copy of this OffsetTime 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:
seconds - the seconds to add, may be negative
Returns:
an OffsetTime based on this time with the seconds added, not null

plusNanos

public OffsetTime plusNanos(long nanos)
Returns a copy of this OffsetTime 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:
nanos - the nanos to add, may be negative
Returns:
an OffsetTime based on this time with the nanoseconds added, not null

minus

public OffsetTime minus(PeriodProvider periodProvider)
Returns a copy of this OffsetTime with the specified period subtracted.

This subtracts the specified period from this time, returning a new time. The calculation wraps around midnight and ignores any date-based ISO fields.

The period is interpreted using rules equivalent to Period.ofTimeFields(PeriodProvider). Those rules ignore any date-based ISO fields, thus adding a date-based period to this time will have no effect.

This instance is immutable and unaffected by this method call.

Parameters:
periodProvider - the period to subtract, not null
Returns:
an OffsetTime based on this time with the period subtracted, not null
Throws:
CalendricalException - if the specified period cannot be converted to a Period
java.lang.ArithmeticException - if the period overflows during conversion to hours/minutes/seconds/nanos

minus

public OffsetTime minus(Duration duration)
Returns a copy of this OffsetTime with the specified duration subtracted.

This subtracts the specified duration to this time, returning a new time. The calculation wraps around midnight.

The calculation is equivalent to using minusSeconds(long) and minusNanos(long) on the two parts of the duration.

This instance is immutable and unaffected by this method call.

Parameters:
duration - the duration to subtract, not null
Returns:
an OffsetTime based on this time with the duration subtracted, not null

minusHours

public OffsetTime minusHours(long hours)
Returns a copy of this OffsetTime 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:
hours - the hours to subtract, may be negative
Returns:
an OffsetTime based on this time with the hours subtracted, not null

minusMinutes

public OffsetTime minusMinutes(long minutes)
Returns a copy of this OffsetTime 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:
minutes - the minutes to subtract, may be negative
Returns:
an OffsetTime based on this time with the minutes subtracted, not null

minusSeconds

public OffsetTime minusSeconds(long seconds)
Returns a copy of this OffsetTime 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:
seconds - the seconds to subtract, may be negative
Returns:
an OffsetTime based on this time with the seconds subtracted, not null

minusNanos

public OffsetTime minusNanos(long nanos)
Returns a copy of this OffsetTime 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:
nanos - the nanos to subtract, may be negative
Returns:
an OffsetTime based on this time with the nanoseconds subtracted, not null

matches

public boolean matches(CalendricalMatcher matcher)
Checks whether this OffsetTime matches the specified matcher.

Matchers can be used to query the time. A simple matcher might simply compare one of the fields, such as the hour field. A more complex matcher might check if the time is the last second of the day.

Parameters:
matcher - the matcher to use, not null
Returns:
true if this time matches the matcher, false otherwise

matchesCalendrical

public boolean matchesCalendrical(Calendrical calendrical)
Checks if the time extracted from the calendrical matches this.

This method implements the CalendricalMatcher interface. It is intended that applications use matches(javax.time.calendar.CalendricalMatcher) rather than this method.

Specified by:
matchesCalendrical in interface CalendricalMatcher
Parameters:
calendrical - the calendrical to match, not null
Returns:
true if the calendrical matches, false otherwise

toLocalTime

public LocalTime toLocalTime()
Converts this time to a LocalTime.

Returns:
a LocalTime with the same time as this instance, not null

compareTo

public int compareTo(OffsetTime other)
Compares this OffsetTime to another time based on the UTC equivalent times then local time.

This ordering is consistent with equals(). For example, the following is the comparator order:

  1. 10:30+01:00
  2. 11:00+01:00
  3. 12:00+02:00
  4. 11:30+01:00
  5. 12:00+01:00
  6. 12:30+01:00
Values #2 and #3 represent the same instant on the time-line. When two values represent the same instant, the local time is compared to distinguish them. This step is needed to make the ordering consistent with equals().

Specified by:
compareTo in interface java.lang.Comparable<OffsetTime>
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(OffsetTime other)
Checks if the instant of this OffsetTime is after that of the specified time applying both times to a common date.

This method differs from the comparison in compareTo(javax.time.calendar.OffsetTime) in that it only compares the instant of the time. This is equivalent to converting both times to an instant using the same date and comparing the instants.

Parameters:
other - the other time to compare to, not null
Returns:
true if this is after the instant of the specified time

isBefore

public boolean isBefore(OffsetTime other)
Checks if the instant of this OffsetTime is before that of the specified time applying both times to a common date.

This method differs from the comparison in compareTo(javax.time.calendar.OffsetTime) in that it only compares the instant of the time. This is equivalent to converting both times to an instant using the same date and comparing the instants.

Parameters:
other - the other time to compare to, not null
Returns:
true if this is before the instant of the specified time

equalInstant

public boolean equalInstant(OffsetTime other)
Checks if the instant of this OffsetTime is equal to that of the specified time applying both times to a common date.

This method differs from the comparison in compareTo(javax.time.calendar.OffsetTime) and equals(java.lang.Object) in that it only compares the instant of the time. This is equivalent to converting both times to an instant using the same date and comparing the instants.

Parameters:
other - the other time to compare to, not null
Returns:
true if this is equal to the instant of the specified time

equals

public boolean equals(java.lang.Object obj)
Checks if this time is equal to another time.

The comparison is based on the local-time and the offset. To compare for the same instant on the time-line, use equalInstant(javax.time.calendar.OffsetTime).

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

hashCode

public int hashCode()
A hash code for this time.

Overrides:
hashCode in class java.lang.Object
Returns:
a suitable hash code

toString

public java.lang.String toString()
Outputs this time as a String, such as 10:15:30+01:00.

The output will be one of the following ISO-8601 formats:

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:
java.lang.UnsupportedOperationException - if the formatter cannot print
CalendricalException - if an error occurs during printing