模块  java.base
软件包  java.time

Class LocalTime

  • 实现的所有接口
    SerializableComparable<LocalTime>TemporalTemporalAccessorTemporalAdjuster

    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
    • 字段详细信息

      • MIN

        public static final LocalTime MIN
        最低支持LocalTime ,'00: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 - 要使用的时钟,不为空
        结果
        当前时间,不是空
      • of

        public static LocalTime of​(int hour,
                                   int minute)
        从一小时一分钟获得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的 second
        结果
        当地时间,不是空的
        异常
        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和offset来计算本地时间。

        参数
        instant - 创建时间的瞬间,而不是null
        zone - 时区,可以是偏移量,不为空
        结果
        当地时间,不是空的
        从以下版本开始:
        9
      • ofSecondOfDay

        public static LocalTime ofSecondOfDay​(long secondOfDay)
        从第二天的值获得LocalTime的实例。

        这将返回具有指定的第二天的LocalTime 纳秒字段将设置为零。

        参数
        secondOfDay - 第二天,从 024 * 60 * 60 - 1
        结果
        当地时间,不是空的
        异常
        DateTimeException - 如果第二天的值无效
      • ofNanoOfDay

        public static LocalTime ofNanoOfDay​(long nanoOfDay)
        从nanos-of-day值获得LocalTime的实例。

        这将返回具有指定纳秒数的LocalTime

        参数
        nanoOfDay - 纳米日,从 024 * 60 * 60 * 1,000,000,000 - 1
        结果
        当地时间,不是空的
        异常
        DateTimeException - 如果 DateTimeException日值无效
      • from

        public static LocalTime from​(TemporalAccessor temporal)
        从时态对象获得LocalTime的实例。

        这基于指定的时间获得本地时间。 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”,而不是null
        结果
        解析的本地时间,不为空
        异常
        DateTimeParseException - 如果无法解析文本
      • parse

        public static LocalTime parse​(CharSequence text,
                                      DateTimeFormatter formatter)
        使用特定格式化程序从文本字符串中获取LocalTime的实例。

        使用格式化程序解析文本,返回时间。

        参数
        text - 要解析的文本,而不是null
        formatter - 要使用的格式化程序,而不是null
        结果
        解析的本地时间,不为空
        异常
        DateTimeParseException - 如果无法解析文本
      • isSupported

        public boolean isSupported​(TemporalField field)
        检查是否支持指定的字段。

        这将检查是否可以查询指定字段的时间。 如果是假,然后调用rangegetwith(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 ,则通过调用this作为参数调用TemporalField.isSupportedBy(TemporalAccessor)获得此方法的结果。 字段是否受支持由字段确定。

        Specified by:
        isSupported ,界面 TemporalAccessor
        参数
        字段 - 要检查的字段,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
        结果
        如果可以添加/减去单位,则为true,否则为false
      • range

        public ValueRange range​(TemporalField field)
        获取指定字段的有效值范围。

        范围对象表示字段的最小和最大有效值。 此时间用于提高返回范围的准确性。 如果无法返回范围,因为不支持该字段或由于某些其他原因,将引发异常。

        如果该字段是ChronoField则在此处实现查询。 supported fields将返回适当的范围实例。 所有其他ChronoField实例将抛出UnsupportedTemporalTypeException

        如果该字段不是ChronoField ,则通过调用this作为参数调用TemporalField.rangeRefinedBy(TemporalAccessor)获得此方法的结果。 是否可以获得范围由该字段确定。

        Specified by:
        range在界面 TemporalAccessor
        参数
        字段 - 要查询范围的字段,而不是null
        结果
        字段的有效值范围,不为null
        异常
        DateTimeException - 如果无法获得该字段的范围
        UnsupportedTemporalTypeException - 如果不支持该字段
      • get

        public int get​(TemporalField field)
        int获取此时指定字段的值。

        这次查询指定字段的值。 返回的值将始终在该字段的有效值范围内。 如果无法返回该值,因为不支持该字段或由于某些其他原因,将引发异常。

        如果该字段是ChronoField则在此处执行查询。 supported fields将根据此时间返回有效值,但NANO_OF_DAYMICRO_OF_DAY除外,它们太大而无法放入int并抛出UnsupportedTemporalTypeException 所有其他ChronoField实例将抛出UnsupportedTemporalTypeException

        如果该字段是不是一个ChronoField ,则此方法的结果是通过调用获得TemporalField.getFrom(TemporalAccessor)传递this作为参数。 是否可以获得该值以及该值表示的值由该字段确定。

        Specified by:
        get在界面 TemporalAccessor
        参数
        字段 - 要获取的字段,而不是null
        结果
        该字段的值
        异常
        DateTimeException - 如果无法获取该字段的值或该值超出该字段的有效值范围
        UnsupportedTemporalTypeException - 如果不支持该字段或值的范围超过 int
        ArithmeticException - 如果发生数字溢出
      • getLong

        public long getLong​(TemporalField field)
        long获取此时指定字段的值。

        这次查询指定字段的值。 如果无法返回该值,因为不支持该字段或由于某些其他原因,将引发异常。

        如果该字段是ChronoField则在此处执行查询。 supported fields将根据此时间返回有效值。 所有其他ChronoField实例将抛出UnsupportedTemporalTypeException

        如果该字段不是ChronoField ,则通过调用this作为参数调用TemporalField.getFrom(TemporalAccessor)获得此方法的结果。 是否可以获得该值以及该值表示的值由该字段确定。

        Specified by:
        getLong在界面 TemporalAccessor
        参数
        字段 - 要获取的字段,而不是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 ,基于此,调整时间。 使用指定的调整器策略对象进行调整。 阅读调整器的文档,了解将进行哪些调整。

        简单的调整器可能只是设置其中一个字段,例如小时字段。 更复杂的调节器可能会将时间设置为当天的最后一小时。

        此方法的结果是通过调用获得TemporalAdjuster.adjustInto(Temporal)在经过指定的调节方法this作为参数。

        此实例是不可变的,不受此方法调用的影响。

        Specified by:
        with在界面 Temporal
        参数
        adjuster - 要使用的调整器,不为null
        结果
        a LocalTime基于 this并进行了调整,而不是null
        异常
        DateTimeException - 如果无法进行调整
        ArithmeticException - 如果发生数字溢出
      • with

        public LocalTime with​(TemporalField field,
                              long newValue)
        返回此时间的副本,并将指定字段设置为新值。

        这将返回LocalTime (基于此值),并更改指定字段的值。 这可用于更改任何支持的字段,例如小时,分钟或秒。 如果无法设置该值,因为不支持该字段或由于某些其他原因,将引发异常。

        如果该字段是ChronoField则在此处执行调整。 支持的字段表现如下:

        • NANO_OF_SECOND - 返回具有指定的LocalTime级的LocalTime 小时,分钟和秒将保持不变。
        • NANO_OF_DAY - 返回具有指定纳米天数的LocalTime 这完全取代了时间,相当于ofNanoOfDay(long)
        • MICRO_OF_SECOND - 返回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返回LocalTime 小时,分钟和纳秒将保持不变。
        • SECOND_OF_DAY - 返回指定的第二天的LocalTime 纳秒将保持不变。
        • MINUTE_OF_HOUR - 返回指定分钟数的LocalTime 小时,秒,秒和纳秒将保持不变。
        • MINUTE_OF_DAY - 返回指定分钟的LocalTime 第二分钟和纳秒将保持不变。
        • HOUR_OF_AMPM - 返回一个LocalTime其中包含指定的上午小时。 AM / PM,分钟,分钟和纳秒将保持不变。
        • CLOCK_HOUR_OF_AMPM - 返回一个指定的clock-hour-am-pm的LocalTime 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
        参数
        字段 - 要在结果中设置的字段,不为null
        newValue - 结果中字段的新值
        结果
        一个 LocalTime基于 this使用指定的字段设置,不为空
        异常
        DateTimeException - 如果无法设置该字段
        UnsupportedTemporalTypeException - 如果不支持该字段
        ArithmeticException - 如果发生数字溢出
      • withHour

        public LocalTime withHour​(int hour)
        返回此LocalTime的副本,并更改日期。

        此实例是不可变的,不受此方法调用的影响。

        参数
        hour - 在结果中设置的小时,从0到23
        结果
        基于此时间的 LocalTime ,请求小时,不为空
        异常
        DateTimeException - 如果小时值无效
      • withMinute

        public LocalTime withMinute​(int minute)
        返回此LocalTime的副本,其中每分钟更改一次。

        此实例是不可变的,不受此方法调用的影响。

        参数
        minute - 在结果中设置的分钟数,从0到59
        结果
        基于此时间的 LocalTime ,请求分钟,不为空
        异常
        DateTimeException - 如果分钟值无效
      • withSecond

        public LocalTime withSecond​(int second)
        返回此LocalTime的副本,并在第二分钟更改。

        此实例是不可变的,不受此方法调用的影响。

        参数
        second - 在结果中设置的 second ,从0到59
        结果
        基于此时间的 LocalTime与请求的秒,不为空
        异常
        DateTimeException - 如果第二个值无效
      • withNano

        public LocalTime withNano​(int nanoOfSecond)
        返回此LocalTime的副本,其中纳秒级已更改。

        此实例是不可变的,不受此方法调用的影响。

        参数
        nanoOfSecond - 在结果中设置的纳秒数,从0到999,999,999
        结果
        基于此时间的 LocalTime ,请求纳秒,不为空
        异常
        DateTimeException - 如果nanos值无效
      • truncatedTo

        public LocalTime truncatedTo​(TemporalUnit unit)
        返回此LocalTime的副本,并截断时间。

        截断返回原始时间的副本,其中小于指定单位的字段设置为零。 例如,使用minutes单位截断将第二分钟和纳秒级字段设置为零。

        该单位必须有一个duration ,它分为标准日的长度,没有余数。 这包括ChronoUnitDAYS上提供的所有时间单位。 其他单位抛出异常。

        此实例是不可变的,不受此方法调用的影响。

        参数
        unit - 要截断的单位,而不是null
        结果
        基于此时间的 LocalTime ,截断时间,不为空
        异常
        DateTimeException - 如果无法截断
        UnsupportedTemporalTypeException - 如果不支持该装置
      • plus

        public LocalTime plus​(TemporalAmount amountToAdd)
        返回此时间的副本,并添加指定的数量。

        这将返回基于此值的LocalTime ,并添加指定的数量。 金额通常为Duration但可以是实现TemporalAmount界面的任何其他类型。

        通过调用TemporalAmount.addTo(Temporal)将计算委托给amount对象。 实施金额可以任意方式自由实施,但通常会回拨给plus(long, TemporalUnit) 请参阅金额实施的文档,以确定是否可以成功添加。

        此实例是不可变的,不受此方法调用的影响。

        Specified by:
        plus在界面 Temporal
        参数
        amountToAdd - 要添加的金额,不为空
        结果
        基于此时间的 LocalTime添加,不为空
        异常
        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 ,则通过调用this作为参数调用TemporalUnit.addTo(Temporal, long)获得此方法的结果。 在这种情况下,该单元确定是否以及如何执行添加。

        此实例是不可变的,不受此方法调用的影响。

        Specified by:
        plus在界面 Temporal
        参数
        amountToAdd - 要添加到结果中的单位数量可能为负数
        unit - 要添加的金额的单位,而不是空
        结果
        基于此时间的 LocalTime ,添加了指定的金额,而不是空
        异常
        DateTimeException - 如果无法添加
        UnsupportedTemporalTypeException - 如果不支持该装置
        ArithmeticException - 如果发生数字溢出
      • plusHours

        public LocalTime plusHours​(long hoursToAdd)
        返回此LocalTime的副本,并添加指定的小时数。

        这会将指定的小时数添加到此时,返回新的时间。 计算在午夜左右。

        此实例是不可变的,不受此方法调用的影响。

        参数
        hoursToAdd - 要添加的小时数,可能是负数
        结果
        基于此时间的 LocalTime ,添加小时数,不为空
      • plusMinutes

        public LocalTime plusMinutes​(long minutesToAdd)
        返回此LocalTime的副本,并添加指定的分钟数。

        这会将指定的分钟数添加到此时,返回新的时间。 计算在午夜左右。

        此实例是不可变的,不受此方法调用的影响。

        参数
        minutesToAdd - 要添加的分钟数,可能是负数
        结果
        基于此时间的 LocalTime ,添加分钟,不为空
      • plusSeconds

        public LocalTime plusSeconds​(long secondstoAdd)
        返回此LocalTime的副本,并添加指定的秒数。

        这会将指定的秒数添加到此时,返回新的时间。 计算在午夜左右。

        此实例是不可变的,不受此方法调用的影响。

        参数
        secondstoAdd - 要添加的秒数,可能是负数
        结果
        基于此时间的 LocalTime ,添加秒数,不为空
      • plusNanos

        public LocalTime plusNanos​(long nanosToAdd)
        返回此LocalTime的副本, LocalTime添加了指定的纳秒数。

        这会在此时添加指定的纳秒数,从而返回新的时间。 计算在午夜左右。

        此实例是不可变的,不受此方法调用的影响。

        参数
        nanosToAdd - 要添加的 nanosToAdd ,可能是负面的
        结果
        基于此时间的 LocalTime ,加上纳秒,不为空
      • minus

        public LocalTime minus​(TemporalAmount amountToSubtract)
        返回此时间的副本,并减去指定的数量。

        这将返回一个LocalTime ,基于此值,减去指定的数量。 金额通常为Duration但可能是实现TemporalAmount界面的任何其他类型。

        通过调用TemporalAmount.subtractFrom(Temporal)将计算委托给amount对象。 实现量可以以任何方式自由地实现减法,但是它通常会回调到minus(long, TemporalUnit) 请参阅金额实施的文档,以确定是否可以成功减去它。

        此实例是不可变的,不受此方法调用的影响。

        Specified by:
        minus ,界面 Temporal
        参数
        amountToSubtract - 要减去的金额,而不是空
        结果
        基于此时间的 LocalTime进行减法,不为空
        异常
        DateTimeException - 如果无法进行减法
        ArithmeticException - 如果发生数字溢出
      • minus

        public LocalTime minus​(long amountToSubtract,
                               TemporalUnit unit)
        返回此时间的副本,并减去指定的数量。

        这将返回一个LocalTime ,基于此值,减去单位的数量。 如果无法减去金额,因为不支持该单位或由于某些其他原因,则抛出异常。

        该方法相当于plus(long, TemporalUnit) ,其数量为负。 有关添加和减法如何工作的完整描述,请参阅该方法。

        此实例是不可变的,不受此方法调用的影响。

        Specified by:
        minus在界面 Temporal
        参数
        amountToSubtract - 从结果中减去的单位数量可能是负数
        unit - 要减去的金额的单位,而不是空
        结果
        基于此时间的 LocalTime ,减去指定的金额,不为空
        异常
        DateTimeException - 如果无法进行减法
        UnsupportedTemporalTypeException - 如果不支持该装置
        ArithmeticException - 如果发生数字溢出
      • minusHours

        public LocalTime minusHours​(long hoursToSubtract)
        返回此LocalTime的副本,并减去指定的小时数。

        从此时间减去指定的小时数,返回新的时间。 计算在午夜左右。

        此实例是不可变的,不受此方法调用的影响。

        参数
        hoursToSubtract - 减去的小时数,可能是负数
        结果
        基于此时间的 LocalTime减去小时数,不为空
      • 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减去纳秒,而不是空
      • query

        public <R> R query​(TemporalQuery<R> query)
        这次使用指定的查询进行查询。

        这次使用指定的查询策略对象进行查询。 TemporalQuery对象定义用于获取结果的逻辑。 阅读查询文档以了解此方法的结果。

        通过在指定的查询上调用TemporalQuery.queryFrom(TemporalAccessor)方法作为参数传递this来获得此方法的结果。

        Specified by:
        query在界面 TemporalAccessor
        参数类型
        R - 结果的类型
        参数
        query - 要调用的查询,而不是null
        结果
        查询结果,可以返回null(由查询定义)
        异常
        DateTimeException - 如果无法查询(由查询定义)
        ArithmeticException - 如果发生数字溢出(由查询定义)
      • adjustInto

        public Temporal adjustInto​(Temporal temporal)
        调整指定的时态对象以使其与此对象具有相同的时间。

        这将返回与输入相同的可观察类型的时间对象,并将时间更改为与此相同。

        该调整是相当于使用Temporal.with(TemporalField, long)传递ChronoField.NANO_OF_DAY作为字段。

        在大多数情况下,使用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
        结果
        调整后的对象,不为空
        异常
        DateTimeException - 如果无法进行调整
        ArithmeticException - 如果发生数字溢出
      • until

        public long until​(Temporal endExclusive,
                          TemporalUnit unit)
        根据指定的单位计算到另一个时间的时间量。

        这将根据单个TemporalUnit计算两个LocalTime对象之间的时间量。 起点和终点是this和指定的时间。 如果结束在开始之前,结果将是否定的。 所述Temporal传递给此方法被转换为LocalTime使用from(TemporalAccessor) 例如,可以使用startTime.until(endTime, HOURS)计算两次之间的小时startTime.until(endTime, HOURS)

        计算返回一个整数,表示两次之间的完整单位数。 例如,11:30到13:29之间的小时数仅为1小时,因为它是两小时的一分钟。

        使用此方法有两种等效方法。 第一种是调用此方法。 第二种是使用TemporalUnit.between(Temporal, Temporal)

          // these two lines are equivalent
           amount = start.until(end, MINUTES);
           amount = MINUTES.between(start, end); 
        应该根据哪个使代码更具可读性来做出选择。

        该计算在ChronoUnit此方法中实施 单位NANOSMICROSMILLISSECONDSMINUTESHOURSHALF_DAYS支持。 其他ChronoUnit值将引发异常。

        如果单位不是ChronoUnit ,则通过调用this作为第一个参数并将转换后的输入temporal作为第二个参数,获得TemporalUnit.between(Temporal, Temporal)获得此方法的结果。

        此实例是不可变的,不受此方法调用的影响。

        Specified by:
        until ,界面 Temporal
        参数
        endExclusive - 结束时间,独占,转换为 LocalTime ,不为空
        unit - 计量金额的单位,而不是空
        结果
        此时间与结束时间之间的时间量
        异常
        DateTimeException - 如果金额无法计算,或结束时间不能转换为 LocalTime
        UnsupportedTemporalTypeException - 如果不支持该单元
        ArithmeticException - 如果发生数字溢出
      • format

        public String format​(DateTimeFormatter formatter)
        这次使用指定的格式化程序格式化。

        此时间将传递给格式化程序以生成字符串。

        参数
        formatter - 要使用的格式化程序,不为null
        结果
        格式化的时间字符串,不为空
        异常
        DateTimeException - 如果在打印期间发生错误
      • atDate

        public LocalDateTime atDate​(LocalDate date)
        将此时间与日期相结合以创建LocalDateTime

        这将返回在此时间在指定日期形成的LocalDateTime 所有可能的日期和时间组合均有效。

        参数
        date - 要结合的日期,而不是null
        结果
        从此时间和指定日期形成的本地日期时间,不为空
      • atOffset

        public OffsetTime atOffset​(ZoneOffset offset)
        将此时间与偏移量组合以创建OffsetTime

        这将返回从此时间在指定偏移量处形成的OffsetTime 所有可能的时间和偏移组合都是有效的。

        参数
        offset - 要与之结合的偏移量,而不是null
        结果
        从此时间和指定的偏移量形成的偏移时间,不为空
      • toSecondOfDay

        public int toSecondOfDay()
        将时间提取为一天中的秒数,从 024 * 60 * 60 - 1
        结果
        相当于这个时间的第二天
      • toNanoOfDay

        public long toNanoOfDay()
        024 * 60 * 60 * 1,000,000,000 - 1 ,将时间提取为 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 - 本地日期,不为空
        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对象,其他类型返回false。 要比较两个TemporalAccessor实例的日期,请使用ChronoField.NANO_OF_DAY作为比较器。

        重写:
        equals ,课程 Object
        参数
        obj - 要检查的对象,null返回false
        结果
        如果这等于另一个时间,则为true
        另请参见:
        Object.hashCode()HashMap
      • 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