Module  java.base
软件包  java.time

Class LocalTime

  • All Implemented Interfaces:
    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'。 这是一天开始的午夜时间。
      • 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 - 第二天,从 024 * 60 * 60 - 1
        结果
        当地时间,不为空
        异常
        DateTimeException - 如果第二天的值无效
      • ofNanoOfDay

        public static LocalTime ofNanoOfDay​(long nanoOfDay)
        LocalTime价值获取LocalTime的实例。

        这将返回一个LocalTime与指定的纳秒。

        参数
        nanoOfDay - nanoOfDay日,从 024 * 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,
                                      DateTimeFormatter formatter)
        使用特定的格式化程序从文本字符串获取LocalTime的实例。

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

        参数
        text - 要解析的文本,不为空
        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 ,则此方法的结果是通过调用得到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_DAYMICRO_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 ,分为标准日期的长度, 无余数。 这包括所有提供的时间单位ChronoUnitDAYS 其他单位抛出异常。

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

        参数
        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 单位NANOSMICROSMILLISSECONDSMINUTESHOURSHALF_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​()
        提取时间为一天的秒数,从 024 * 60 * 60 - 1
        结果
        第二天相当于这个时候
      • toNanoOfDay

        public long toNanoOfDay​()
        提取时间为天数,从 024 * 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作为比较器。

        重写:
        equalsObject
        参数
        obj - 要检查的对象,null返回false
        结果
        如果这等于其他时间,则为真
        另请参见:
        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
        所使用的格式将是将省略部分隐含为零的时间的全部值输出的最短。
        重写:
        toStringObject
        结果
        这个时间的字符串表示,不为null