All Implemented Interfaces:

Serializable ， Comparable<LocalTime> ， Temporal ， TemporalAccessor ， TemporalAdjuster
```
public final class LocalTime
extends Object
implements Temporal, TemporalAdjuster, Comparable<LocalTime>, Serializable
```
在ISO- 10:15:30 ，如10:15:30 。
LocalTime是一个不可变的日期时间对象，代表一个时间，通常被视为小时 - 秒。时间表示为纳秒精度。例如，值“13：45.30.123456789”可以存储在LocalTime 。

该类不存储或表示日期或时区。相反，它是当地时间的描述，如在挂钟上看到的。它不能表示时间线上的瞬时，没有附加信息，如偏移或时区。

ISO-8601日历系统是当今世界绝大多数的现代民用日历系统。该API假定所有日历系统在时间上使用相同的表示，这个类。

这是一个value-based课; 对LocalTime实例使用身份敏感操作（包括引用等式（ == ），身份哈希码或同步）可能会产生不可预测的结果，应该避免。 equals方法应用于比较。

实现要求：

这个类是不可变的和线程安全的。

从以下版本开始：

1.8

另请参见：

Serialized Form

Field Summary

Fields
Modifier and Type	Field	描述
`static LocalTime`	`MAX`	最大支持 `LocalTime` ，'23：59：59.999999999'。
`static LocalTime`	`MIDNIGHT`	午夜开始的时候，'00：00'。
`static LocalTime`	`MIN`	最低支持 `LocalTime` ：00'。
`static LocalTime`	`NOON`	中午的时候，“12：00”。

方法摘要

所有方法静态方法接口方法具体的方法
Modifier and Type	方法	描述
`Temporal`	`adjustInto(Temporal temporal)`	调整指定的时间对象与此对象具有相同的时间。
`LocalDateTime`	`atDate(LocalDate date)`	结合这个时间与一个日期来创建一个 `LocalDateTime` 。
`OffsetTime`	`atOffset(ZoneOffset offset)`	结合这个时间与偏移创建一个 `OffsetTime` 。
`int`	`compareTo(LocalTime other)`	比较这个时间到另一个时间。
`boolean`	`equals(Object obj)`	检查这次是否等于另一次。
`String`	`format(DateTimeFormatter formatter)`	此时使用指定的格式化程序格式化。
`static LocalTime`	`from(TemporalAccessor temporal)`	从时间对象获取 `LocalTime`的实例。
`int`	`get(TemporalField field)`	从此时间获取指定字段的值作为 `int` 。
`int`	`getHour()`	获取时间字段。
`long`	`getLong(TemporalField field)`	从此时间获取指定字段的值作为 `long` 。
`int`	`getMinute()`	获取小时字段。
`int`	`getNano()`	获得纳秒第二场。
`int`	`getSecond()`	获得第二分钟的字段。
`int`	`hashCode()`	这个时候的哈希码。
`boolean`	`isAfter(LocalTime other)`	检查此时间是否在指定时间后。
`boolean`	`isBefore(LocalTime other)`	检查此时间是否在指定时间之前。
`boolean`	`isSupported(TemporalField field)`	检查指定的字段是否受支持。
`boolean`	`isSupported(TemporalUnit unit)`	检查指定的单位是否受支持。
`LocalTime`	`minus(long amountToSubtract, TemporalUnit unit)`	返回此次的副本，减去指定的金额。
`LocalTime`	`minus(TemporalAmount amountToSubtract)`	返回此次的副本，减去指定的金额。
`LocalTime`	`minusHours(long hoursToSubtract)`	返回此 `LocalTime`的副本，并减去指定的小时数。
`LocalTime`	`minusMinutes(long minutesToSubtract)`	返回此 `LocalTime`的副本，并减去指定的分钟数。
`LocalTime`	`minusNanos(long nanosToSubtract)`	返回此 `LocalTime`的副本，减去指定的纳秒数。
`LocalTime`	`minusSeconds(long secondsToSubtract)`	返回此 `LocalTime`的副本，并减去指定的秒数。
`static LocalTime`	`now()`	从默认时区的系统时钟获取当前时间。
`static LocalTime`	`now(Clock clock)`	从指定的时钟获取当前时间。
`static LocalTime`	`now(ZoneId zone)`	从指定时区的系统时钟获取当前时间。
`static LocalTime`	`of(int hour, int minute)`	从一分钟内获得 `LocalTime`的实例。
`static LocalTime`	`of(int hour, int minute, int second)`	从一小时，一分钟和秒钟获得 `LocalTime`的实例。
`static LocalTime`	`of(int hour, int minute, int second, int nanoOfSecond)`	从一小时，分钟，秒和纳秒获取 `LocalTime`的实例。
`static LocalTime`	`ofInstant(Instant instant, ZoneId zone)`	从 `Instant`和区域ID获取 `LocalTime`的实例。
`static LocalTime`	`ofNanoOfDay(long nanoOfDay)`	从 `LocalTime`价值获取 `LocalTime`的实例。
`static LocalTime`	`ofSecondOfDay(long secondOfDay)`	从第二天的价值获得一个 `LocalTime`的实例。
`static LocalTime`	`parse(CharSequence text)`	从 `10:15`等文本字符串获取 `LocalTime`的实例。
`static LocalTime`	`parse(CharSequence text, DateTimeFormatter formatter)`	使用特定的格式化程序从文本字符串获取 `LocalTime`的实例。
`LocalTime`	`plus(long amountToAdd, TemporalUnit unit)`	返回此时添加了指定数量的副本。
`LocalTime`	`plus(TemporalAmount amountToAdd)`	返回此时添加了指定数量的副本。
`LocalTime`	`plusHours(long hoursToAdd)`	返回此 `LocalTime`的副本，并添加指定的小时数。
`LocalTime`	`plusMinutes(long minutesToAdd)`	返回此 `LocalTime`的副本，并附加指定的分钟数。
`LocalTime`	`plusNanos(long nanosToAdd)`	返回此 `LocalTime`的副本， `LocalTime`添加了指定的纳秒数。
`LocalTime`	`plusSeconds(long secondstoAdd)`	返回此 `LocalTime`的副本，并添加指定的秒数。
`<R> R`	`query(TemporalQuery<R> query)`	此时使用指定的查询进行查询。
`ValueRange`	`range(TemporalField field)`	获取指定字段的有效值的范围。
`long`	`toEpochSecond(LocalDate date, ZoneOffset offset)`	将此 `LocalTime`转换为自1970-01-01T00：00：00Z的时代以来的秒数。
`long`	`toNanoOfDay()`	提取时间为天数，从 `0`到 `24 * 60 * 60 * 1,000,000,000 - 1` 。
`int`	`toSecondOfDay()`	提取时间为每天的秒数，从 `0`到 `24 * 60 * 60 - 1` 。
`String`	`toString()`	此时输出为 `String` ，如 `10:15` 。
`LocalTime`	`truncatedTo(TemporalUnit unit)`	返回此 `LocalTime`的副本，截断时间。
`long`	`until(Temporal endExclusive, TemporalUnit unit)`	根据指定的单位计算直到另一次的时间量。
`LocalTime`	`with(TemporalAdjuster adjuster)`	返回此次调整后的副本。
`LocalTime`	`with(TemporalField field, long newValue)`	返回此时间的副本，并将指定的字段设置为新值。
`LocalTime`	`withHour(int hour)`	返回 `LocalTime`的副本，并更改日期。
`LocalTime`	`withMinute(int minute)`	返回此 `LocalTime`的副本，小时更改。
`LocalTime`	`withNano(int nanoOfSecond)`	返回这个 `LocalTime`的副本， `LocalTime`改变了。
`LocalTime`	`withSecond(int second)`	返回此 `LocalTime`的副本，并更改了第二分钟。

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

- 字段详细信息
  - MIN
```
public static final LocalTime MIN
```
    最低支持LocalTime ：00'。这是一天开始的午夜时间。
  - MAX
```
public static final LocalTime MAX
```
    最大支持LocalTime ，'23：59：59.999999999'。这是在一天结束之前的午夜之前的时间。
  - MIDNIGHT
```
public static final LocalTime MIDNIGHT
```
    午夜开始的时候，'00：00'。
  - NOON
```
public static final LocalTime NOON
```
    中午的时候，“12：00”。
- 方法详细信息
  - now
```
public static LocalTime now()
```
    从默认时区的系统时钟获取当前时间。
    这将在默认时区查询system clock以获取当前时间。
    
    使用此方法将阻止使用备用时钟进行测试，因为时钟是硬编码的。
    
    结果
    
    当前时间使用系统时钟和默认时区，不为空
  - now
```
public static LocalTime now(ZoneId zone)
```
    从指定时区的系统时钟获取当前时间。
    这将查询system clock获取当前时间。指定时区可以避免对默认时区的依赖。
    
    使用此方法将阻止使用备用时钟进行测试，因为时钟是硬编码的。
    
    参数
    
    zone - 要使用的区域ID，不为空
    
    结果
    
    当前时间使用系统时钟，不为空
  - now
```
public static LocalTime now(Clock clock)
```
    从指定的时钟获取当前时间。
    这将查询指定的时钟以获取当前时间。使用此方法可以使用备用时钟进行测试。备用时钟可以使用dependency injection引入。
    
    参数
    
    clock - 要使用的时钟，不为空
    
    结果
    
    当前时间，不为null
  - of
```
public static LocalTime of(int hour,
                           int minute)
```
    从一小时分钟获得LocalTime的实例。
    这LocalTime指定的小时和分钟返回LocalTime 。第二和第十二个字段将被设置为零。
    
    参数
    
    hour - 代表从0到23的小时
    
    minute - 从0到59表示的小时
    
    结果
    
    当地时间，不为空
    
    异常
    
    DateTimeException - 如果任何字段的值超出范围
  - of
```
public static LocalTime of(int hour,
                           int minute,
                           int second)
```
    从一小时，分钟和秒钟获取LocalTime的实例。
    这将返回一个LocalTime与指定的小时，分钟和秒。纳秒场将被设置为零。
    
    参数
    
    hour - 代表从0到23的小时
    
    minute - 从0到59表示的小时
    
    second - 从0到59的秒表示
    
    结果
    
    当地时间，不为空
    
    异常
    
    DateTimeException - 如果任何字段的值超出范围
  - of
```
public static LocalTime of(int hour,
                           int minute,
                           int second,
                           int nanoOfSecond)
```
    从一小时，分钟，秒和纳秒获取LocalTime的实例。
    这将返回一个LocalTime指定的小时，分钟，秒和纳秒。
    
    参数
    
    hour - 代表从0到23的小时
    
    minute - 从0到59表示的小时
    
    second - 从0到59的秒表示
    
    nanoOfSecond - 表示从0到999,999,999的纳秒
    
    结果
    
    当地时间，不为空
    
    异常
    
    DateTimeException - 如果任何字段的值超出范围
  - ofInstant
```
public static LocalTime ofInstant(Instant instant,
                                  ZoneId zone)
```
    从Instant和区域ID获取LocalTime的实例。
    这将根据指定的时间创建本地时间。首先，使用区域ID和时刻获取UTC /格林威治的偏移量，这很简单，因为每个时刻只有一个有效的偏移量。然后，使用瞬时和偏移来计算当地时间。
    
    参数
    
    instant - 即时创建时间，不为null
    
    zone - 时区，可能是偏移，不为空
    
    结果
    
    当地时间，不为空
    
    从以下版本开始：
    
    9
  - ofSecondOfDay
```
public static LocalTime ofSecondOfDay(long secondOfDay)
```
    从第二天的价值获取一个LocalTime的实例。
    这将返回一个LocalTime与指定的第二天。纳秒场将被设置为零。
    
    参数
    
    secondOfDay - 第二天，从 0到 24 * 60 * 60 - 1
    
    结果
    
    当地时间，不为空
    
    异常
    
    DateTimeException - 如果第二天的值无效
  - ofNanoOfDay
```
public static LocalTime ofNanoOfDay(long nanoOfDay)
```
    从LocalTime价值获取LocalTime的实例。
    这将返回一个LocalTime与指定的纳秒。
    
    参数
    
    nanoOfDay - nanoOfDay日，从 0到 24 * 60 * 60 * 1,000,000,000 - 1
    
    结果
    
    当地时间，不为空
    
    异常
    
    DateTimeException - 如果天数的 DateTimeException无效
  - from
```
public static LocalTime from(TemporalAccessor temporal)
```
    从时间对象获取一个LocalTime的实例。
    这取决于指定时间的本地时间。 A TemporalAccessor表示一个任意的日期和时间信息集，该工厂转换为LocalTime一个实例。
    
    转换使用TemporalQueries.localTime()查询，它依赖于提取NANO_OF_DAY字段。
    
    该方法匹配功能接口TemporalQuery的签名，允许其通过方法参考LocalTime::from用作查询。
    
    参数
    
    temporal - 要转换的时间对象，不为null
    
    结果
    
    当地时间，不为空
    
    异常
    
    DateTimeException - 如果无法转换为 LocalTime
  - parse
```
public static LocalTime parse(CharSequence text)
```
    从10:15等文本字符串获取LocalTime的实例。
    字符串必须表示有效时间，并使用DateTimeFormatter.ISO_LOCAL_TIME进行解析。
    
    参数
    
    text - 要解析的文本，如“10:15:30”，不为空
    
    结果
    
    解析当地时间，不为空
    
    异常
    
    DateTimeParseException - 如果文本无法解析
  - parse
```
public static LocalTime parse(CharSequence text,
                              DateTimeFormatter formatter)
```
    使用特定的格式化程序从文本字符串获取LocalTime的实例。
    使用格式化程序解析文本，返回一个时间。
    
    参数
    
    text - 要解析的文本，不为空
    
    formatter - 要使用的格式化程序，不为null
    
    结果
    
    解析当地时间，不为空
    
    异常
    
    DateTimeParseException - 如果文本无法解析
  - isSupported
```
public boolean isSupported(TemporalField field)
```
    检查指定的字段是否受支持。
    这将检查此时间是否可以查询指定的字段。如果是假，然后调用range ， get和with(TemporalField, long)方法会抛出异常。
    
    如果该字段是一个ChronoField，那么查询是在这里实现的。支持的字段有：
    
    NANO_OF_SECOND
    
    NANO_OF_DAY
    
    MICRO_OF_SECOND
    
    MICRO_OF_DAY
    
    MILLI_OF_SECOND
    
    MILLI_OF_DAY
    
    SECOND_OF_MINUTE
    
    SECOND_OF_DAY
    
    MINUTE_OF_HOUR
    
    MINUTE_OF_DAY
    
    HOUR_OF_AMPM
    
    CLOCK_HOUR_OF_AMPM
    
    HOUR_OF_DAY
    
    CLOCK_HOUR_OF_DAY
    
    AMPM_OF_DAY
    
    所有其他ChronoField实例将返回false。
    如果该字段是不是一个ChronoField ，则此方法的结果是通过调用得到TemporalField.isSupportedBy(TemporalAccessor)传递this作为参数。字段是否受支持由字段决定。
    Specified by:
    
    isSupported在接口 TemporalAccessor
    
    参数
    
    field - 要检查的字段，null返回false
    
    结果
    
    如果此时支持该字段，则为true，否则为false
  - isSupported
```
public boolean isSupported(TemporalUnit unit)
```
    检查指定的单位是否受支持。
    这将检查指定的单位是否可以被添加到这个时间或从这个时间减去。如果是false，那么调用plus(long, TemporalUnit)和minus方法会抛出异常。
    
    如果单位是ChronoUnit，那么查询是在这里实现的。支持的单位是：
    
    NANOS
    
    MICROS
    
    MILLIS
    
    SECONDS
    
    MINUTES
    
    HOURS
    
    HALF_DAYS
    
    所有其他ChronoUnit实例将返回false。
    如果单位不是ChronoUnit ，则通过调用TemporalUnit.isSupportedBy(Temporal)通过this作为参数获得该方法的结果。设备是否受支持由本机决定。
    Specified by:
    
    isSupported在接口 Temporal
    
    参数
    
    unit - 要检查的单位，null返回false
    
    结果
    
    如果可以添加/减去单位，则为真，否则为false
  - range
```
public ValueRange range(TemporalField field)
```
    获取指定字段的有效值的范围。
    范围对象表示字段的最小和最大有效值。这次用于提高返回范围的准确性。如果不可能返回范围，因为该字段不受支持或出于某种其他原因，则抛出异常。
    
    如果该字段是一个ChronoField，那么查询是在这里实现的。 supported fields将返回适当的范围实例。所有其他ChronoField实例将抛出一个UnsupportedTemporalTypeException 。
    
    如果该字段是不是一个ChronoField ，则此方法的结果是通过调用得到TemporalField.rangeRefinedBy(TemporalAccessor)传递this作为参数。是否可以获得范围由字段确定。
    
    Specified by:
    
    range在接口 TemporalAccessor
    
    参数
    
    field - 查询范围的字段，不为null
    
    结果
    
    字段的有效值的范围不为null
    
    异常
    
    DateTimeException - 如果不能获得字段的范围
    
    UnsupportedTemporalTypeException - 如果不支持该字段
  - get
```
public int get(TemporalField field)
```
    从此时间获取指定字段的值作为int 。
    此时会查询指定字段的值。返回的值将始终在该字段的值的有效范围内。如果不可能返回值，因为该字段不受支持或出于某种其他原因，则抛出异常。
    
    如果该字段是一个ChronoField，那么查询是在这里实现的。 supported fields将返回基于此时间的有效值，除了NANO_OF_DAY和MICRO_OF_DAY ，这些值太大，无法适应int并抛出UnsupportedTemporalTypeException 。所有其他ChronoField实例将抛出一个UnsupportedTemporalTypeException 。
    
    如果该字段是不是一个ChronoField ，则此方法的结果是通过调用得到TemporalField.getFrom(TemporalAccessor)传递this作为参数。该值是否可以获得，该值代表什么值由该字段决定。
    
    Specified by:
    
    get在接口 TemporalAccessor
    
    参数
    
    field - 要获取的字段，不为null
    
    结果
    
    该字段的值
    
    异常
    
    DateTimeException - 如果无法获取字段的值，或者该值超出了该字段的有效值的范围
    
    UnsupportedTemporalTypeException - 如果字段不受支持或值的范围超过 int
    
    ArithmeticException - 如果发生数字溢出
  - getLong
```
public long getLong(TemporalField field)
```
    从此时间获取指定字段的值为long 。
    此时会查询指定字段的值。如果不可能返回值，因为该字段不受支持或出于某种其他原因，则抛出异常。
    
    如果该字段是一个ChronoField，那么查询是在这里实现的。 supported fields将返回基于此时间的有效值。所有其他ChronoField实例将抛出一个UnsupportedTemporalTypeException 。
    
    如果该字段是不是一个ChronoField ，则此方法的结果是通过调用得到TemporalField.getFrom(TemporalAccessor)传递this作为参数。该值是否可以获得，该值代表什么值由该字段决定。
    
    Specified by:
    
    getLong在接口 TemporalAccessor
    
    参数
    
    field - 要获取的字段，不为null
    
    结果
    
    该字段的值
    
    异常
    
    DateTimeException - 如果无法获取该字段的值
    
    UnsupportedTemporalTypeException - 如果该字段不被支持
    
    ArithmeticException - 如果发生数字溢出
  - getHour
```
public int getHour()
```
    获取时间字段。
    
    结果
    
    时间从0到23
  - getMinute
```
public int getMinute()
```
    获取小时字段。
    
    结果
    
    分钟，从0到59
  - getSecond
```
public int getSecond()
```
    获得第二分钟的字段。
    
    结果
    
    第二分钟，从0到59
  - getNano
```
public int getNano()
```
    获得纳秒第二场。
    
    结果
    
    纳秒，从0到999,999,999
  - with
```
public LocalTime with(TemporalAdjuster adjuster)
```
    返回此次调整后的副本。
    这返回一个LocalTime ，基于这一个，随着时间的推移。调整使用指定的调整器策略对象进行。阅读调整器的文档，了解将进行什么调整。
    
    一个简单的调整器可以简单地设置一个字段，如小时字段。更复杂的调整器可能会将时间设置为一天中的最后一个小时。
    
    该方法的结果是通过调用270602882841991方法，通过this作为参数。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    with在接口 Temporal
    
    参数
    
    adjuster - 调整器使用，不为空
    
    结果
    
    一个 LocalTime基于 this进行了调整，不为null
    
    异常
    
    DateTimeException - 如果不能进行调整
    
    ArithmeticException - 如果发生数字溢出
  - with
```
public LocalTime with(TemporalField field,
                      long newValue)
```
    返回此时间的副本，并将指定的字段设置为新值。
    这将返回一个LocalTime ，基于此，更改指定字段的值。这可以用于更改任何支持的字段，如小时，分钟或秒。如果不可能设置该值，因为该字段不受支持或出于某种其他原因，则抛出异常。
    
    如果该字段是ChronoField，则在此处执行调整。支持的字段的行为如下：
    
    NANO_OF_SECOND - 返回一个LocalTime具有指定的纳秒。小时，分和秒将保持不变。
    
    NANO_OF_DAY - 返回指定纳秒的LocalTime 。这完全取代了时间，相当于ofNanoOfDay(long) 。
    
    MICRO_OF_SECOND - 返回一个LocalTime ，以秒为单位的LocalTime数乘以指定的微秒乘以1,000。小时，分和秒将保持不变。
    
    MICRO_OF_DAY - 返回一个LocalTime与指定的微型日。这完全取代了时间，相当于使用ofNanoOfDay(long)与微日相乘1,000。
    
    MILLI_OF_SECOND - 返回LocalTime ，以秒为单位，以秒为单位替换为1,000,000。小时，分和秒将保持不变。
    
    MILLI_OF_DAY - 返回指定毫米的LocalTime 。这完全取代了时间，相当于使用ofNanoOfDay(long)毫秒的日子乘以1,000,000。
    
    SECOND_OF_MINUTE - 返回指定秒钟的LocalTime 。小时，分钟和毫秒都不变。
    
    SECOND_OF_DAY - 返回指定的第二天的LocalTime 。纳秒将不变。
    
    MINUTE_OF_HOUR - 返回一个LocalTime与指定的分钟小时。小时，秒钟和纳秒将保持不变。
    
    MINUTE_OF_DAY - 返回指定分钟的LocalTime 。二分之一秒和二分之一秒将不变。
    
    HOUR_OF_AMPM - 返回一个LocalTime与指定的上午pm。 AM / PM，分钟小时，秒钟和纳秒将不变。
    
    CLOCK_HOUR_OF_AMPM - 返回一个LocalTime与指定的时钟上午pm。 AM / PM，分钟小时，秒钟和纳秒将不变。
    
    HOUR_OF_DAY - 返回一个LocalTime与指定的小时。分钟小时，秒钟和纳秒将保持不变。
    
    CLOCK_HOUR_OF_DAY - 返回一个LocalTime具有指定的时钟 - 时间。分钟小时，秒钟和纳秒将保持不变。
    
    AMPM_OF_DAY - 返回具有指定AM / PM的LocalTime 。上午的小时，分钟，小时和二分之一秒将不变。
    
    在所有情况下，如果新值超出了字段值的有效范围，则抛出DateTimeException 。
    
    所有其他ChronoField实例将抛出一个UnsupportedTemporalTypeException 。
    
    如果该字段是不是一个ChronoField ，则此方法的结果是通过调用得到TemporalField.adjustInto(Temporal, long)传递this作为参数。在这种情况下，该字段决定是否以及如何调整即时。
    
    此实例是不可变的，不受此方法调用的影响。
    Specified by:
    
    with在接口 Temporal
    
    参数
    
    field - 要在结果中设置的字段，不为null
    
    newValue - 结果中字段的新值
    
    结果
    
    一个 LocalTime基于 this与指定的字段集，不为null
    
    异常
    
    DateTimeException - 如果该字段无法设置
    
    UnsupportedTemporalTypeException - 如果该字段不被支持
    
    ArithmeticException - 如果发生数字溢出
  - withHour
```
public LocalTime withHour(int hour)
```
    返回此LocalTime的副本，并更改日期。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    hour - 设置结果的小时数，从0到23
    
    结果
    
    一个 LocalTime基于这个时间与请求的小时，不为null
    
    异常
    
    DateTimeException - 如果小时值无效
  - withMinute
```
public LocalTime withMinute(int minute)
```
    返回此LocalTime的副本，小时改变。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    minute - 在0到59之间设置的小时
    
    结果
    
    一个 LocalTime基于此时间与请求的分钟，不为null
    
    异常
    
    DateTimeException - 如果分钟值无效
  - withSecond
```
public LocalTime withSecond(int second)
```
    返回此LocalTime的副本，第二分钟更改。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    second - 在0到59之间设置结果的 second
    
    结果
    
    一个 LocalTime基于此时与请求的第二个，不为null
    
    异常
    
    DateTimeException - 如果第二个值无效
  - withNano
```
public LocalTime withNano(int nanoOfSecond)
```
    返回这个LocalTime的副本，并修改了纳秒。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    nanoOfSecond - 纳秒在结果中设置，从0到999,999,999
    
    结果
    
    一个 LocalTime基于这个时间与请求的纳秒，不为null
    
    异常
    
    DateTimeException - 如果 DateTimeException值无效
  - truncatedTo
```
public LocalTime truncatedTo(TemporalUnit unit)
```
    返回此LocalTime的副本，截断时间。
    截断返回原始时间的副本，其中小于指定单位的字段设置为零。例如，使用minutes单元截断将将第二分钟和纳秒的字段设置为零。
    
    该单位必须有一个duration ，分为标准日期的长度，无余数。这包括所有提供的时间单位ChronoUnit和DAYS 。其他单位抛出异常。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    unit - 截断到的单位，不为null
    
    结果
    
    一个 LocalTime基于此时间截断，不为null
    
    异常
    
    DateTimeException - 如果不能截断
    
    UnsupportedTemporalTypeException - 如果不支持本机
  - plus
```
public LocalTime plus(TemporalAmount amountToAdd)
```
    返回此时添加了指定数量的副本。
    这将返回一个LocalTime ，基于此，添加指定的数量。金额通常为Duration，但可能是实现TemporalAmount接口的任何其他类型。
    
    通过调用TemporalAmount.addTo(Temporal)将计算委托给金额对象。数量执行可以以任何愿望的方式实现添加，但通常可以回调到plus(long, TemporalUnit) 。请参阅金额执行的文档，以确定是否可以成功添加。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    plus在接口 Temporal
    
    参数
    
    amountToAdd - 要添加的金额，不为null
    
    结果
    
    一个 LocalTime基于这个时间加上，而不是null
    
    异常
    
    DateTimeException - 如果不能添加
    
    ArithmeticException - 如果发生数字溢出
  - plus
```
public LocalTime plus(long amountToAdd,
                      TemporalUnit unit)
```
    返回此时添加了指定数量的副本。
    这将返回一个LocalTime ，基于这一个，以添加的单位数量。如果不可能添加金额，因为单位不受支持或出于某种其他原因，则抛出异常。
    
    如果该字段是一个ChronoUnit，那么添加在这里实现。支持的字段的行为如下：
    
    NANOS - 返回一个LocalTime ，加上指定的纳秒数。这相当于plusNanos(long) 。
    
    MICROS - 返回一个LocalTime ，加上指定的微秒数。这相当于plusNanos(long) ，数量乘以1,000。
    
    MILLIS - 返回指定的毫秒数的LocalTime 。相当于plusNanos(long) ，金额乘以1,000,000。
    
    SECONDS - 返回一个LocalTime ，加上指定的秒数。这相当于plusSeconds(long) 。
    
    MINUTES - 返回一个LocalTime ，加上指定的分钟数。这相当于plusMinutes(long) 。
    
    HOURS - 返回一个LocalTime ，加上指定的小时数。这相当于plusHours(long) 。
    
    HALF_DAYS - 返回一个LocalTime ，加上指定的半天。这相当于plusHours(long) ，数量乘以12。
    
    所有其他ChronoUnit实例将抛出一个UnsupportedTemporalTypeException 。
    
    如果该字段是不是一个ChronoUnit ，则此方法的结果是通过调用得到TemporalUnit.addTo(Temporal, long)传递this作为参数。在这种情况下，单元确定是否以及如何执行添加。
    
    此实例是不可变的，不受此方法调用的影响。
    Specified by:
    
    plus在接口 Temporal
    
    参数
    
    amountToAdd - 添加到结果中的单位数量可能为负数
    
    unit - 要添加的单位，不为null
    
    结果
    
    一个 LocalTime基于这个时间与指定的数量添加，不为null
    
    异常
    
    DateTimeException - 如果不能添加
    
    UnsupportedTemporalTypeException - 如果不支持本机
    
    ArithmeticException - 如果发生数字溢出
  - plusHours
```
public LocalTime plusHours(long hoursToAdd)
```
    返回此LocalTime的副本，并附加指定的小时数。
    这样就增加了指定的小时数，返回一个新的时间。计算周期在午夜。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    hoursToAdd - 添加的时间可能为负数
    
    结果
    
    一个 LocalTime基于这个时间加上的时间，不是null
  - plusMinutes
```
public LocalTime plusMinutes(long minutesToAdd)
```
    以指定的分钟数返回此LocalTime的副本。
    这样就添加了指定的分钟数，返回一个新的时间。计算周期在午夜。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    minutesToAdd - 要添加的分钟，可能为负数
    
    结果
    
    一个 LocalTime基于这个时间加上分钟，不为null
  - plusSeconds
```
public LocalTime plusSeconds(long secondstoAdd)
```
    返回此LocalTime的副本，并添加指定的秒数。
    这样就增加了指定的秒数，返回一个新的时间。计算周期在午夜。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    secondstoAdd - 要添加的秒数，可能为负数
    
    结果
    
    一个 LocalTime基于这个时间与秒添加，不为null
  - plusNanos
```
public LocalTime plusNanos(long nanosToAdd)
```
    返回此LocalTime的副本， LocalTime添加了指定的纳秒数。
    这样就增加了指定的纳秒数，返回一个新的时间。计算周期在午夜。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    nanosToAdd - nanosToAdd添加，可能是负的
    
    结果
    
    一个 LocalTime基于这个时间加上纳秒，不是null
  - minus
```
public LocalTime minus(TemporalAmount amountToSubtract)
```
    返回此次的副本，减去指定的金额。
    这将返回一个LocalTime ，基于此，减去指定的数量。金额通常为Duration，但可能是实现TemporalAmount接口的任何其他类型。
    
    通过调用TemporalAmount.subtractFrom(Temporal)将计算委托给金额对象。数量执行可以任何方式自由实现减法，但是它通常会回调到minus(long, TemporalUnit) 。请参阅数量执行的文档，以确定是否可以成功减去它们。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    minus在接口 Temporal
    
    参数
    
    amountToSubtract - 减去量，不为空
    
    结果
    
    一个 LocalTime基于这个时间与减法而不是null
    
    异常
    
    DateTimeException - 如果不能进行减法
    
    ArithmeticException - 如果发生数字溢出
  - minus
```
public LocalTime minus(long amountToSubtract,
                       TemporalUnit unit)
```
    返回此次的副本，减去指定的金额。
    这将返回一个LocalTime ，基于这一个，减去的单位数量。如果不可能减去金额，因为该单位不受支持或出于某种其他原因，则会抛出异常。
    
    该方法相当于plus(long, TemporalUnit) ，数量被否定。请参阅该方法，以了解如何添加，从而减去运算。
    
    此实例是不可变的，不受此方法调用的影响。
    
    Specified by:
    
    minus在接口 Temporal
    
    参数
    
    amountToSubtract - 从结果中减去的单位数量可能为负数
    
    unit - 减去量的单位，不为空
    
    结果
    
    一个 LocalTime基于此时间减去指定的数量，不为null
    
    异常
    
    DateTimeException - 如果不能进行减法
    
    UnsupportedTemporalTypeException - 如果不支持本机
    
    ArithmeticException - 如果发生数字溢出
  - minusHours
```
public LocalTime minusHours(long hoursToSubtract)
```
    返回此LocalTime的副本，并减去指定的小时数。
    这样从这个时间减去指定的小时数，返回一个新的时间。计算周期在午夜。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    hoursToSubtract - 减去的时间可能为负数
    
    结果
    
    一个 LocalTime基于这个时间减去了小时，不为null
  - minusMinutes
```
public LocalTime minusMinutes(long minutesToSubtract)
```
    返回此LocalTime的副本，并减去指定的分钟数。
    这将从此时间减去指定的分钟数，返回一个新的时间。计算周期在午夜。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    minutesToSubtract - 减去的分数可能为负数
    
    结果
    
    一个 LocalTime基于此时间减去分钟，不为空
  - minusSeconds
```
public LocalTime minusSeconds(long secondsToSubtract)
```
    返回此LocalTime的副本，并减去指定的秒数。
    从此时间减去指定的秒数，返回一个新的时间。计算周期在午夜。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    secondsToSubtract - 减去的秒数可能为负数
    
    结果
    
    一个 LocalTime基于此时间减去秒，不为空
  - minusNanos
```
public LocalTime minusNanos(long nanosToSubtract)
```
    返回此LocalTime的副本，减去指定的纳秒数。
    从这个时间减去指定的纳秒数，返回一个新的时间。计算周期在午夜。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    nanosToSubtract - nanosToSubtract减去，可能是负数
    
    结果
    
    一个 LocalTime基于这个时间减去纳秒，不为null
  - query
```
public <R> R query(TemporalQuery<R> query)
```
    此时使用指定的查询进行查询。
    这样可以使用指定的查询策略对象查询此时间。 TemporalQuery对象定义了用于获取结果的逻辑。阅读查询的文档，以了解该方法的结果。
    
    该方法的结果是通过在指定的查询this作为参数调用TemporalQuery.queryFrom(TemporalAccessor)方法获得的。
    
    Specified by:
    
    query在接口 TemporalAccessor
    
    参数类型
    
    R - 结果的类型
    
    参数
    
    query - 要调用的查询，不为空
    
    结果
    
    查询结果可能返回null（由查询定义）
    
    异常
    
    DateTimeException - 如果无法查询（由查询定义）
    
    ArithmeticException - 如果发生数字溢出（由查询定义）
  - adjustInto
```
public Temporal adjustInto(Temporal temporal)
```
    调整指定的时间对象与此对象具有相同的时间。
    这返回与时间变化相同的输入的相同可观察类型的时间对象。
    
    调整相当于通过ChronoField.NANO_OF_DAY作为字段使用Temporal.with(TemporalField, long) 。
    
    在大多数情况下，通过使用Temporal.with(TemporalAdjuster)来更正呼叫模式：
    
    // these two lines are equivalent, but the second approach is recommended temporal = thisLocalTime.adjustInto(temporal); temporal = temporal.with(thisLocalTime);
    
    此实例是不可变的，不受此方法调用的影响。
    Specified by:
    
    adjustInto在接口 TemporalAdjuster
    
    参数
    
    temporal - 要调整的目标对象，不为null
    
    结果
    
    调整对象，不为null
    
    异常
    
    DateTimeException - 如果不能进行调整
    
    ArithmeticException - 如果发生数字溢出
  - until
```
public long until(Temporal endExclusive,
                  TemporalUnit unit)
```
    根据指定的单位计算直到另一次的时间量。
    这可以计算一个LocalTime对象之间的时间量，单个TemporalUnit 。起点和终点为this和指定时间。如果结束在开始之前，结果将为负数。所述Temporal传递给此方法被转换为LocalTime使用from(TemporalAccessor) 。例如，可以使用startTime.until(endTime, HOURS)计算两次之间的小时startTime.until(endTime, HOURS) 。
    
    计算返回一个整数，表示两次之间的完整单位数。例如，从11:30到13:29之间的小时数将只有一个小时，因为它是两分钟不到两分钟。
    
    使用这种方法有两种等效的方法。第一个是调用这个方法。二是使用TemporalUnit.between(Temporal, Temporal) ：
    
    // these two lines are equivalent amount = start.until(end, MINUTES); amount = MINUTES.between(start, end);
    应该根据这种做法进行选择，使代码更易读。
    该方法的计算用于ChronoUnit 。单位NANOS ， MICROS ， MILLIS ， SECONDS ， MINUTES ， HOURS和HALF_DAYS的支持。其他ChronoUnit值会抛出异常。
    
    如果该单元不是ChronoUnit ，则此方法的结果是通过调用得到TemporalUnit.between(Temporal, Temporal)传递this作为第一个参数和转换后的输入时间作为第二个参数。
    
    此实例是不可变的，不受此方法调用的影响。
    Specified by:
    
    until在接口 Temporal
    
    参数
    
    endExclusive - 结束时间，排他，转换为 LocalTime ，不为空
    
    unit - 衡量金额的单位，不为空
    
    结果
    
    这段时间与结束时间之间的时间量
    
    异常
    
    DateTimeException - 如果不能计算金额，或者结束时间不能转换为 LocalTime
    
    UnsupportedTemporalTypeException - 如果不支持本机
    
    ArithmeticException - 如果发生数字溢出
  - format
```
public String format(DateTimeFormatter formatter)
```
    此时使用指定的格式化程序格式化。
    这一次将被传递给格式化程序来生成一个字符串。
    
    参数
    
    formatter - 要使用的格式化程序，不为null
    
    结果
    
    格式化的时间字符串，不为null
    
    异常
    
    DateTimeException - 打印时是否发生错误
  - atDate
```
public LocalDateTime atDate(LocalDate date)
```
    结合这个时间与日期来创建一个LocalDateTime 。
    这将返回一个LocalDateTime形成从这个时间在指定的日期。日期和时间的所有可能的组合都是有效的。
    
    参数
    
    date - 要结合的日期，不为null
    
    结果
    
    从这个时间和指定的日期形成的本地日期时间，不为null
  - atOffset
```
public OffsetTime atOffset(ZoneOffset offset)
```
    结合这个时间与偏移量创建一个OffsetTime 。
    这将返回一个OffsetTime ，从此时间以指定的偏移量形成。所有可能的时间和偏移的组合都是有效的。
    
    参数
    
    offset - 要组合的偏移量，不为空
    
    结果
    
    从此时间形成的偏移时间和指定的偏移量，不为空
  - toSecondOfDay
```
public int toSecondOfDay()
```
    提取时间为一天的秒数，从 0到 24 * 60 * 60 - 1 。
    
    结果
    
    第二天相当于这个时候
  - toNanoOfDay
```
public long toNanoOfDay()
```
    提取时间为天数，从 0到 24 * 60 * 60 * 1,000,000,000 - 1 。
    
    结果
    
    那天的纳米相当于这个时间
  - toEpochSecond
```
public long toEpochSecond(LocalDate date,
                          ZoneOffset offset)
```
    将此LocalTime转换为从1970-01-01T00：00：00Z开始的秒数。
    这将本地时间与指定的日期和偏移量相结合，以计算从1970-01-01T00：00：00Z开始的秒数的时代秒值。时代之后的时代的实体是积极的，较早的是负的。
    
    参数
    
    date - 本地日期，不为null
    
    offset - 区域偏移，不为空
    
    结果
    
    从1970-01-01T00：00：00Z开始的秒数可能为负数
    
    从以下版本开始：
    
    9
  - compareTo
```
public int compareTo(LocalTime other)
```
    比较这个时间到另一个时间。
    比较是基于一天内当地时间的时间位置。它与“等于”一致，如Comparable所定义。
    
    Specified by:
    
    compareTo在接口 Comparable<LocalTime>
    
    参数
    
    other - 其他时间比较，不是null
    
    结果
    
    比较器值为负，如果较小，则如果较大则为正
  - isAfter
```
public boolean isAfter(LocalTime other)
```
    检查此时间是否在指定时间后。
    比较是基于一天内时间的时间位置。
    
    参数
    
    other - 其他时间比较，不为null
    
    结果
    
    如果这是在指定的时间之后，则为true
  - isBefore
```
public boolean isBefore(LocalTime other)
```
    检查此时间是否在指定时间之前。
    比较是基于一天内时间的时间位置。
    
    参数
    
    other - 其他时间比较，不为null
    
    结果
    
    如果这一点在指定时间之前，则为true
  - equals
```
public boolean equals(Object obj)
```
    检查这次是否等于另一次。
    比较是基于一天内时间的时间位置。
    
    只有LocalTime类型的LocalTime被比较，其他类型返回false。要比较两个TemporalAccessor实例的日期，请使用ChronoField.NANO_OF_DAY作为比较器。
    
    重写：
    
    equals在 Object
    
    参数
    
    obj - 要检查的对象，null返回false
    
    结果
    
    如果这等于其他时间，则为真
    
    另请参见：
    
    Object.hashCode() ， HashMap
  - hashCode
```
public int hashCode()
```
    这个时候的哈希码。
    
    重写：
    
    hashCode在 Object
    
    结果
    
    一个合适的哈希码
    
    另请参见：
    
    Object.equals(java.lang.Object) ， System.identityHashCode(java.lang.Object)
  - toString
```
public String toString()
```
    此时输出为String ，如10:15 。
    输出将是以下ISO-8601格式之一：
    
    HH:mm
    
    HH:mm:ss
    
    HH:mm:ss.SSS
    
    HH:mm:ss.SSSSSS
    
    HH:mm:ss.SSSSSSSSS
    
    所使用的格式将是将省略部分隐含为零的时间的全部值输出的最短。
    重写：
    
    toString在 Object
    
    结果
    
    这个时间的字符串表示，不为null

Class LocalTime

Field Summary

方法摘要

Methods inherited from class java.lang.Object

字段详细信息

MIN

MAX

MIDNIGHT

NOON

方法详细信息

now

now

now

of

of

of

ofInstant

ofSecondOfDay

ofNanoOfDay

from

parse

parse

isSupported

isSupported

range

get

getLong

getHour

getMinute

getSecond

getNano

with

with

withHour

withMinute

withSecond

withNano

truncatedTo

plus

plus

plusHours

plusMinutes

plusSeconds

plusNanos

minus

minus

minusHours

minusMinutes

minusSeconds

minusNanos

query

adjustInto

until

format

atDate

atOffset

toSecondOfDay

toNanoOfDay

toEpochSecond

compareTo

isAfter

isBefore

equals

hashCode

toString