Module java.base
Package java.time

Class Duration

java.lang.Object
java.time.Duration
所有已实现的接口:
Serializable, Comparable<Duration>, TemporalAmount
public final class Duration extends Object implements TemporalAmount, Comparable<Duration>, Serializable
表示时间的时间量，例如'34.5秒'。

该类以秒和纳秒的形式模拟时间的数量或时间量。可以使用其他基于持续时间的单位访问它，例如分钟和小时。此外，可以使用DAYS单位，将其视为等于24小时，因此忽略夏令时效应。请参阅Period以获取与此类相对应的基于日期的等效类。

物理持续时间可能是无限长的。为了实用性，持续时间存储在类似于Instant的约束条件中。持续时间使用纳秒分辨率，最大值为可以保存在long中的秒数。这比当前宇宙的估计年龄还要大。

持续时间的范围需要存储一个大于long的数字。为了实现这一点，该类存储一个代表秒的long和一个代表秒内纳秒的int，始终在0和999,999,999之间。该模型是有向持续时间，意味着持续时间可以是负的。

持续时间以“秒”为单位，但这些秒不一定与基于原子钟的科学“SI秒”定义相同。这种差异仅影响在闰秒附近测量的持续时间，不应影响大多数应用程序。有关秒和时间刻度含义的讨论，请参阅Instant。

这是一个基于值的类；程序员应该将相等的实例视为可互换的，并且不应将实例用于同步，否则可能会发生不可预测的行为。例如，在将来的版本中，同步可能会失败。应该使用equals方法进行比较。

实现要求:
该类是不可变且线程安全的。
自版本:
1.8
另请参见:

  • Field Summary

    Fields
    Modifier and Type
    Field
    Description
    static final Duration
    ZERO
    零持续时间的常量。

  • Method Summary

    Modifier and Type
    Method
    Description
    Duration
    abs()
    返回具有正长度的此持续时间的副本。
    Temporal
    addTo(Temporal temporal)
    将此持续时间添加到指定的时间对象。
    static Duration
    between(Temporal startInclusive, Temporal endExclusive)
    获取表示两个时间对象之间持续时间的Duration。
    int
    compareTo(Duration otherDuration)
    将此持续时间与指定的Duration进行比较。
    Duration
    dividedBy(long divisor)
    返回将此持续时间除以指定值的副本。
    long
    dividedBy(Duration divisor)
    返回指定持续时间在此持续时间内发生的整数倍数。
    boolean
    equals(Object other)
    检查此持续时间是否等于指定的Duration。
    static Duration
    from(TemporalAmount amount)
    从时间量获取Duration的实例。
    long
    get(TemporalUnit unit)
    获取请求单位的值。
    int
    getNano()
    获取此持续时间内秒内的纳秒数。
    long
    getSeconds()
    获取此持续时间内的秒数。
    List<TemporalUnit>
    getUnits()
    获取此持续时间支持的单位集。
    int
    hashCode()
    此持续时间的哈希码。
    boolean
    isNegative()
    检查此持续时间是否为负，不包括零。
    boolean
    isPositive()
    检查此持续时间是否为正，不包括零。
    boolean
    isZero()
    检查此持续时间是否为零长度。
    Duration
    minus(long amountToSubtract, TemporalUnit unit)
    返回将指定持续时间减去此持续时间的副本。
    Duration
    minus(Duration duration)
    返回将指定持续时间减去此持续时间的副本。
    Duration
    minusDays(long daysToSubtract)
    返回将指定持续时间以标准24小时天数减去此持续时间的副本。
    Duration
    minusHours(long hoursToSubtract)
    返回将指定持续时间以小时减去此持续时间的副本。
    Duration
    minusMillis(long millisToSubtract)
    返回将指定持续时间以毫秒减去此持续时间的副本。
    Duration
    minusMinutes(long minutesToSubtract)
    返回将指定持续时间以分钟减去此持续时间的副本。
    Duration
    minusNanos(long nanosToSubtract)
    返回将指定持续时间以纳秒减去此持续时间的副本。
    Duration
    minusSeconds(long secondsToSubtract)
    返回将指定持续时间以秒减去此持续时间的副本。
    Duration
    multipliedBy(long multiplicand)
    返回将此持续时间乘以标量的副本。
    Duration
    negated()
    返回长度取反的此持续时间的副本。
    static Duration
    of(long amount, TemporalUnit unit)
    获取表示指定单位中的数量的Duration。
    static Duration
    ofDays(long days)
    获取表示标准24小时天数的Duration。
    static Duration
    ofHours(long hours)
    获取表示标准小时数的Duration。
    static Duration
    ofMillis(long millis)
    获取表示毫秒数的Duration。
    static Duration
    ofMinutes(long minutes)
    获取表示标准分钟数的Duration。
    static Duration
    ofNanos(long nanos)
    获取表示纳秒数的Duration。
    static Duration
    ofSeconds(long seconds)
    获取表示秒数的Duration。
    static Duration
    ofSeconds(long seconds, long nanoAdjustment)
    获取表示秒数和纳秒调整的Duration。
    static Duration
    parse(CharSequence text)
    从文本字符串（例如PnDTnHnMn.nS）获取Duration。
    Duration
    plus(long amountToAdd, TemporalUnit unit)
    返回将指定持续时间添加到此持续时间的副本。
    Duration
    plus(Duration duration)
    返回将指定持续时间添加到此持续时间的副本。
    Duration
    plusDays(long daysToAdd)
    返回将指定标准24小时天数添加到此持续时间的副本。
    Duration
    plusHours(long hoursToAdd)
    返回将指定小时数添加到此持续时间的副本。
    Duration
    plusMillis(long millisToAdd)
    返回将指定毫秒数添加到此持续时间的副本。
    Duration
    plusMinutes(long minutesToAdd)
    返回将指定分钟数添加到此持续时间的副本。
    Duration
    plusNanos(long nanosToAdd)
    返回将指定纳秒数添加到此持续时间的副本。
    Duration
    plusSeconds(long secondsToAdd)
    返回将指定秒数添加到此持续时间的副本。
    Temporal
    subtractFrom(Temporal temporal)
    从指定的时间对象中减去此持续时间。
    long
    toDays()
    获取此持续时间中的天数。
    long
    toDaysPart()
    提取持续时间中的天数。
    long
    toHours()
    获取此持续时间中的小时数。
    int
    toHoursPart()
    提取持续时间中的小时部分。
    long
    toMillis()
    将此持续时间转换为以毫秒为单位的总长度。
    int
    toMillisPart()
    提取持续时间的毫秒部分。
    long
    toMinutes()
    获取此持续时间中的分钟数。
    int
    toMinutesPart()
    提取持续时间中的分钟部分。
    long
    toNanos()
    将此持续时间转换为以long表示的纳秒总长度。
    int
    toNanosPart()
    获取持续时间中秒内的纳秒部分。
    long
    toSeconds()
    获取此持续时间中的秒数。
    int
    toSecondsPart()
    提取持续时间中的秒部分。
    String
    toString()
    使用基于ISO-8601秒的表示形式的字符串表示此持续时间，例如PT8H6M12.345S。
    Duration
    truncatedTo(TemporalUnit unit)
    返回将此Duration截断为指定单位的副本。
    Duration
    withNanos(int nanoOfSecond)
    返回具有指定秒内纳秒的此持续时间的副本。
    Duration
    withSeconds(long seconds)
    返回具有指定秒数的此持续时间的副本。

    Methods declared in class java.lang.Object

    clone, finalize, getClass, notify, notifyAll, wait, wait, wait

  • Field Details

    • ZERO

      public static final Duration ZERO
      零持续时间的常量。

  • Method Details

    • ofDays

      public static Duration ofDays(long days)
      获取表示标准24小时天数的Duration。

      秒数是基于一天的标准定义计算的，其中每天为86400秒，这意味着一天为24小时。秒内的纳秒字段设置为零。

      参数:
      days - 天数，可以为正数或负数
      返回:
      Duration，不为null
      抛出:
      ArithmeticException - 如果输入的天数超出了Duration的容量

    • ofHours

      public static Duration ofHours(long hours)
      获取表示标准小时数的Duration。

      秒数是基于一小时的标准定义计算的，其中每小时为3600秒。秒内的纳秒字段设置为零。

      参数:
      hours - 小时数，可以为正数或负数
      返回:
      Duration，不为null
      抛出:
      ArithmeticException - 如果输入的小时数超出了Duration的容量

    • ofMinutes

      public static Duration ofMinutes(long minutes)
      获取表示标准分钟数的Duration。

      秒数是基于一分钟的标准定义计算的，其中每分钟为60秒。秒内的纳秒字段设置为零。

      参数:
      minutes - 分钟数，可以为正数或负数
      返回:
      Duration，不为null
      抛出:
      ArithmeticException - 如果输入的分钟数超出了Duration的容量

    • ofSeconds

      public static Duration ofSeconds(long seconds)
      获取表示秒数的Duration。

      秒内的纳秒字段设置为零。

      参数:
      seconds - 秒数，可以为正数或负数
      返回:
      Duration，不为null

    • ofSeconds

      public static Duration ofSeconds(long seconds, long nanoAdjustment)
      获取表示秒数和纳秒调整的Duration。

      此方法允许传入任意数量的纳秒。工厂将更改秒和纳秒的值，以确保存储的纳秒在0到999,999,999之间。例如，以下内容将导致完全相同的持续时间：

        Duration.ofSeconds(3, 1);
  Duration.ofSeconds(4, -999_999_999);
  Duration.ofSeconds(2, 1000_000_001);
      参数:
      seconds - 秒数，可以是正数或负数
      nanoAdjustment - 秒数的纳秒调整，可以是正数或负数
      返回:
      Duration，非空
      抛出:
      ArithmeticException - 如果调整导致秒数超过Duration的容量

    • ofMillis

      public static Duration ofMillis(long millis)
      获取表示毫秒数的Duration。

      从指定的毫秒数中提取秒数和纳秒数。

      参数:
      millis - 毫秒数，可以是正数或负数
      返回:
      Duration，非空

    • ofNanos

      public static Duration ofNanos(long nanos)
      获取表示纳秒数的Duration。

      从指定的纳秒数中提取秒数和纳秒数。

      参数:
      nanos - 纳秒数，可以是正数或负数
      返回:
      Duration，非空

    • of

      public static Duration of(long amount, TemporalUnit unit)
      获取表示指定单位数量的Duration。

      参数表示短语的两部分，例如“6小时”。例如：

        Duration.of(3, SECONDS);
  Duration.of(465, HOURS);
      此方法仅接受部分单位。单位必须具有确切的持续时间，或者是被视为24小时的ChronoUnit.DAYS。其他单位会抛出异常。
      参数:
      amount - 以单位为度量的持续时间量，可以是正数或负数
      unit - 持续时间的度量单位，必须具有确切的持续时间，非空
      返回:
      Duration，非空
      抛出:
      DateTimeException - 如果周期单位具有估计的持续时间
      ArithmeticException - 如果发生数值溢出

    • from

      public static Duration from(TemporalAmount amount)
      从时间量获取Duration的实例。

      根据指定的时间量获取持续时间。 TemporalAmount表示一段时间，可以是基于日期或时间的，此工厂从中提取持续时间。

      转换循环遍历从时间量中获取的单位集，并使用单位的持续时间来计算总Duration。此方法仅接受部分单位。单位必须具有确切的持续时间，或者是被视为24小时的ChronoUnit.DAYS。如果发现任何其他单位，则会抛出异常。

      参数:
      amount - 要转换的时间量，非空
      返回:
      等效的持续时间，非空
      抛出:
      DateTimeException - 如果无法转换为Duration
      ArithmeticException - 如果发生数值溢出

    • parse

      public static Duration parse(CharSequence text)
      从文本字符串（如PnDTnHnMn.nS）获取Duration。

      将解析持续时间的文本表示，包括toString()生成的字符串。接受的格式基于ISO-8601持续时间格式PnDTnHnMn.nS，其中天被视为确切的24小时。

      字符串以可选符号开头，由ASCII负号或正号表示。如果为负，则整个周期为负。接下来是大写或小写的ASCII字母“P”。然后是四个部分，每个部分由数字和后缀组成。部分的后缀为ASCII中的“D”、“H”、“M”和“S”，分别表示天、小时、分钟和秒，接受大写或小写。后缀必须按顺序出现。如果有小时、分钟或秒部分，则ASCII字母“T”必须在第一个出现之前。至少必须存在四个部分之一，如果存在“T”，则“T”后必须至少有一个部分。每个部分的数字部分必须由一个或多个ASCII数字组成。数字可能以ASCII负号或正号为前缀。天数、小时数和分钟数必须解析为long。秒数必须解析为带有可选小数部分的long。小数点可以是点或逗号。小数部分可以有零到9位数字。

      前导加号/减号符号以及其他单位的负值不是ISO-8601标准的一部分。

      示例：

          "PT20.345S" -- 解析为"20.345秒"
    "PT15M"     -- 解析为"15分钟"（其中一分钟为60秒）
    "PT10H"     -- 解析为"10小时"（其中一小时为3600秒）
    "P2D"       -- 解析为"2天"（其中一天为24小时或86400秒）
    "P2DT3H4M"  -- 解析为"2天、3小时和4分钟"
    "PT-6H3M"    -- 解析为"-6小时和+3分钟"
    "-PT6H3M"    -- 解析为"-6小时和-3分钟"
    "-PT-6H+3M"  -- 解析为"+6小时和-3分钟"
      参数:
      text - 要解析的文本，非空
      返回:
      解析后的持续时间，非空
      抛出:
      DateTimeParseException - 如果无法将文本解析为持续时间

    • between

      public static Duration between(Temporal startInclusive, Temporal endExclusive)
      获取两个时间对象之间的持续时间的Duration。

      计算两个时间对象之间的持续时间。如果对象类型不同，则基于第一个对象的类型计算持续时间。例如，如果第一个参数是LocalTime，则将第二个参数转换为LocalTime。

      指定的时间对象必须支持SECONDS单位。为了获得完全准确的结果，应支持NANOS单位或NANO_OF_SECOND字段。

      此方法的结果可能是负周期，如果结束时间在开始时间之前。要确保获得正持续时间，请对结果调用abs()。

      参数:
      startInclusive - 起始时间，包含，非空
      endExclusive - 结束时间，不包含，非空
      返回:
      Duration，非空
      抛出:
      DateTimeException - 如果无法获取时间之间的秒数
      ArithmeticException - 如果计算超出Duration的容量

    • get

      public long get(TemporalUnit unit)
      获取所请求单位的值。

      对于两个支持的单位，SECONDS和NANOS，返回一个值。所有其他单位都会抛出异常。

      指定者:
      get 在接口 TemporalAmount
      参数:
      unit - 要返回值的TemporalUnit
      返回:
      单位的长整型值
      抛出:
      DateTimeException - 如果不支持该单位
      UnsupportedTemporalTypeException - 如果不支持该单位

    • getUnits

      public List<TemporalUnit> getUnits()
      获取此持续时间支持的单位集。

      支持的单位为SECONDS和NANOS。它们按照秒和纳秒的顺序返回。

      此集合可与get(TemporalUnit)一起使用，以访问持续时间的整个状态。

      指定者:
      getUnits 在接口 TemporalAmount
      返回:
      包含秒和纳秒单位的列表，非空

    • isPositive

      public boolean isPositive()
      检查此持续时间是否为正数，不包括零。

      Duration表示时间线上两点之间的有向距离，因此可以是正数、零或负数。此方法检查长度是否大于零。

      返回:
      如果此持续时间的总长度大于零，则为true
      自:
      18

    • isZero

      public boolean isZero()
      检查此持续时间是否为零长度。

      Duration表示时间线上两点之间的有向距离，因此可以是正数、零或负数。此方法检查长度是否为零。

      返回:
      如果此持续时间的总长度等于零，则为true

    • isNegative

      public boolean isNegative()
      检查此持续时间是否为负数，不包括零。

      Duration表示时间线上两点之间的有向距禮，因此可以是正数、零或负数。此方法检查长度是否小于零。

      返回:
      如果此持续时间的总长度小于零，则为true

    • getSeconds

      public long getSeconds()
      获取此持续时间中的秒数。

      持续时间的长度使用两个字段存储 - 秒和纳秒。纳秒部分是0到999,999,999之间的值，用于调整秒数的长度。通过调用此方法和getNano()来定义总持续时间。

      Duration表示时间线上两点之间的有向距离。负持续时间由秒部分的负号表示。-1纳秒的持续时间存储为-1秒加上999,999,999纳秒。

      返回:
      持续时间长度的整秒部分，可以是正数或负数

    • getNano

      public int getNano()
      获取持续时间内的纳秒数。

      持续时间的长度使用两个字段存储 - 秒和纳秒。纳秒部分的值范围从0到999,999,999，是对秒数长度的调整。总持续时间通过调用此方法和getSeconds()来定义。

      Duration表示时间线上两点之间的有向距离。负持续时间由秒部分的负号表示。-1纳秒的持续时间存储为-1秒加上999,999,999纳秒。

      返回:
      持续时间长度的秒内纳秒部分，范围从0到999,999,999

    • withSeconds

      public Duration withSeconds(long seconds)
      返回具有指定秒数的此持续时间的副本。

      返回具有指定秒数的持续时间，保留此持续时间的纳秒部分。

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

      参数:
      seconds - 要表示的秒数，可以是负数
      返回:
      基于此持续时间的持续时间，具有请求的秒数，非空

    • withNanos

      public Duration withNanos(int nanoOfSecond)
      返回具有指定纳秒数的此持续时间的副本。

      返回具有指定纳秒数的持续时间，保留此持续时间的秒部分。

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

      参数:
      nanoOfSecond - 要表示的纳秒数，范围从0到999,999,999
      返回:
      基于此持续时间的持续时间，具有请求的纳秒数，非空
      抛出:
      DateTimeException - 如果纳秒数无效

    • plus

      public Duration plus(Duration duration)
      返回添加了指定持续时间的此持续时间的副本。

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

      参数:
      duration - 要添加的持续时间，可以是正数或负数，非空
      返回:
      基于此持续时间的持续时间，添加了指定的持续时间，非空
      抛出:
      ArithmeticException - 如果发生数值溢出

    • plus

      public Duration plus(long amountToAdd, TemporalUnit unit)
      返回减去指定持续时间的此持续时间的副本。

      持续时间量是根据指定单位来衡量的。此方法仅接受单位的子集。单位必须具有精确的持续时间，或者是被视为24小时的ChronoUnit.DAYS。其他单位会抛出异常。

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

      参数:
      amountToAdd - 要添加的数量，以单位衡量，可以是正数或负数
      unit - 数量所衡量的单位，必须具有精确的持续时间，非空
      返回:
      基于此持续时间的持续时间，添加了指定的持续时间，非空
      抛出:
      UnsupportedTemporalTypeException - 如果不支持该单位
      ArithmeticException - 如果发生数值溢出

    • plusDays

      public Duration plusDays(long daysToAdd)
      返回添加了指定标准24小时天数的此持续时间的副本。

      天数乘以86400以获得要添加的秒数。这基于一天定义为24小时的标准。

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

      参数:
      daysToAdd - 要添加的天数，可以是正数或负数
      返回:
      基于此持续时间的持续时间，添加了指定的天数，非空
      抛出:
      ArithmeticException - 如果发生数值溢出

    • plusHours

      public Duration plusHours(long hoursToAdd)
      返回添加了指定小时数的此持续时间的副本。

      小时数乘以3600以获得要减去的秒数。

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

      参数:
      hoursToAdd - 要添加的小时数，可以是正数或负数
      返回:
      基于此持续时间的持续时间，添加了指定的小时数，非空
      抛出:
      ArithmeticException - 如果发生数值溢出

    • plusMinutes

      public Duration plusMinutes(long minutesToAdd)
      返回添加了指定分钟数的此持续时间的副本。

      分钟数乘以60以获得要减去的秒数。

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

      参数:
      minutesToAdd - 要添加的分钟数，可以是正数或负数
      返回:
      基于此持续时间的持续时间，添加了指定的分钟数，非空
      抛出:
      ArithmeticException - 如果发生数值溢出

    • plusSeconds

      public Duration plusSeconds(long secondsToAdd)
      返回添加了指定秒数的此持续时间的副本。

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

      参数:
      secondsToAdd - 要添加的秒数，可以是正数或负数
      返回:
      基于此持续时间的持续时间，添加了指定的秒数，非空
      抛出:
      ArithmeticException - 如果发生数值溢出

    • plusMillis

      public Duration plusMillis(long millisToAdd)
      返回添加了指定毫秒数的此持续时间的副本。

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

      参数:
      millisToAdd - 要添加的毫秒数，可以是正数或负数
      返回:
      基于此持续时间的持续时间，添加了指定的毫秒数，非空
      抛出:
      ArithmeticException - 如果发生数值溢出

    • plusNanos

      public Duration plusNanos(long nanosToAdd)
      返回添加了指定纳秒数的此持续时间的副本。

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

      参数:
      nanosToAdd - 要添加的纳秒数，可以是正数或负数
      返回:
      基于此持续时间的持续时间，添加了指定的纳秒数，非空
      抛出:
      ArithmeticException - 如果发生数值溢出

    • minus

      public Duration minus(Duration duration)
      返回减去指定持续时间的此持续时间的副本。

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

      参数:
      duration - 要减去的持续时间，可以是正数或负数，非空
      返回:
      基于此持续时间的持续时间，减去了指定的持续时间，非空
      抛出:
      ArithmeticException - 如果发生数值溢出

    • minus

      public Duration minus(long amountToSubtract, TemporalUnit unit)
      返回减去指定持续时间的此持续时间的副本。

      持续时间量是根据指定单位来衡量的。此方法仅接受单位的子集。单位必须具有精确的持续时间，或者是被视为24小时的ChronoUnit.DAYS。其他单位会抛出异常。

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

      参数:
      amountToSubtract - 要减去的数量，以单位衡量，可以是正数或负数
      unit - 数量所衡量的单位，必须具有精确的持续时间，非空
      返回:
      基于此持续时间的持续时间，减去了指定的持续时间，非空
      抛出:
      ArithmeticException - 如果发生数值溢出

    • minusDays

      public Duration minusDays(long daysToSubtract)
      返回减去指定标准24小时天数的此持续时间的副本。

      天数乘以86400以获得要减去的秒数。这基于一天定义为24小时的标准。

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

      参数:
      daysToSubtract - 要减去的天数，可以是正数或负数
      返回:
      基于此持续时间的持续时间，减去了指定的天数，非空
      抛出:
      ArithmeticException - 如果发生数值溢出

    • minusHours

      public Duration minusHours(long hoursToSubtract)
      返回减去指定小时数的此持续时间的副本。

      小时数乘以3600以获得要减去的秒数。

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

      参数:
      hoursToSubtract - 要减去的小时数，可以是正数或负数
      返回:
      基于此持续时间的持续时间，减去了指定的小时数，非空
      抛出:
      ArithmeticException - 如果发生数值溢出

    • minusMinutes

      public Duration minusMinutes(long minutesToSubtract)
      返回减去指定分钟数的此持续时间的副本。

      分钟数乘以60以获得要减去的秒数。

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

      参数:
      minutesToSubtract - 要减去的分钟数，可以是正数或负数
      返回:
      基于此持续时间的一个Duration，减去指定分钟数后的结果，不为null
      抛出:
      ArithmeticException - 如果发生数值溢出

    • minusSeconds

      public Duration minusSeconds(long secondsToSubtract)
      返回一个减去指定秒数后的此持续时间的副本。

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

      参数:
      secondsToSubtract - 要减去的秒数，可以是正数或负数
      返回:
      基于此持续时间的一个Duration，减去指定秒数后的结果，不为null
      抛出:
      ArithmeticException - 如果发生数值溢出

    • minusMillis

      public Duration minusMillis(long millisToSubtract)
      返回一个减去指定毫秒数后的此持续时间的副本。

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

      参数:
      millisToSubtract - 要减去的毫秒数，可以是正数或负数
      返回:
      基于此持续时间的一个Duration，减去指定毫秒数后的结果，不为null
      抛出:
      ArithmeticException - 如果发生数值溢出

    • minusNanos

      public Duration minusNanos(long nanosToSubtract)
      返回一个减去指定纳秒数后的此持续时间的副本。

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

      参数:
      nanosToSubtract - 要减去的纳秒数，可以是正数或负数
      返回:
      基于此持续时间的一个Duration，减去指定纳秒数后的结果，不为null
      抛出:
      ArithmeticException - 如果发生数值溢出

    • multipliedBy

      public Duration multipliedBy(long multiplicand)
      返回一个乘以标量后的此持续时间的副本。

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

      参数:
      multiplicand - 要将持续时间乘以的值，可以是正数或负数
      返回:
      基于此持续时间的一个Duration，乘以指定标量后的结果，不为null
      抛出:
      ArithmeticException - 如果发生数值溢出

    • dividedBy

      public Duration dividedBy(long divisor)
      返回一个除以指定值后的此持续时间的副本。

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

      参数:
      divisor - 要将持续时间除以的值，可以是正数或负数，不能为零
      返回:
      基于此持续时间的一个Duration，除以指定除数后的结果，不为null
      抛出:
      ArithmeticException - 如果除数为零或发生数值溢出

    • dividedBy

      public long dividedBy(Duration divisor)
      返回指定持续时间在此持续时间内完整发生的次数。

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

      参数:
      divisor - 要将持续时间除以的值，可以是正数或负数，不能为null
      返回:
      指定Duration在此持续时间内完整发生的次数，向零舍入，可能为负数
      抛出:
      ArithmeticException - 如果除数为零或发生数值溢出
      自:
      9

    • negated

      public Duration negated()
      返回一个长度取反后的此持续时间的副本。

      此方法交换此持续时间的总长度的符号。例如，PT1.3S将返回为PT-1.3S。

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

      返回:
      基于此持续时间的一个Duration，取反后的结果，不为null
      抛出:
      ArithmeticException - 如果发生数值溢出

    • abs

      public Duration abs()
      返回一个长度为正的此持续时间的副本。

      此方法通过有效地从任何负总长度中去除符号来返回一个正持续时间。例如，PT-1.3S将返回为PT1.3S。

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

      返回:
      基于此持续时间的一个Duration，绝对长度的结果，不为null
      抛出:
      ArithmeticException - 如果发生数值溢出

    • addTo

      public Temporal addTo(Temporal temporal)
      将此持续时间添加到指定的时间对象中。

      这将返回一个与输入相同可观察类型的时间对象，其中添加了此持续时间。

      在大多数情况下，通过使用Temporal.plus(TemporalAmount)来反转调用模式会更清晰。

         // 这两行是等效的，但推荐第二种方法
   dateTime = thisDuration.addTo(dateTime);
   dateTime = dateTime.plus(thisDuration);

      计算将先添加秒数，然后纳秒数。只会添加非零数量。

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

      指定者:
      addTo 在接口 TemporalAmount
      参数:
      temporal - 要调整的时间对象，不能为null
      返回:
      调整后的相同类型对象，不为null
      抛出:
      DateTimeException - 如果无法添加
      ArithmeticException - 如果发生数值溢出

    • subtractFrom

      public Temporal subtractFrom(Temporal temporal)
      从指定的时间对象中减去此持续时间。

      这将返回一个与输入相同可观察类型的时间对象，其中减去了此持续时间。

      在大多数情况下，通过使用Temporal.minus(TemporalAmount)来反转调用模式会更清晰。

         // 这两行是等效的，但推荐第二种方法
   dateTime = thisDuration.subtractFrom(dateTime);
   dateTime = dateTime.minus(thisDuration);

      计算将先减去秒数，然后纳秒数。只会添加非零数量。

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

      指定者:
      subtractFrom 在接口 TemporalAmount
      参数:
      temporal - 要调整的时间对象，不能为null
      返回:
      调整后的相同类型对象，不为null
      抛出:
      DateTimeException - 如果无法减去
      ArithmeticException - 如果发生数值溢出

    • toDays

      public long toDays()
      获取此持续时间中的天数。

      通过将秒数除以86400来返回持续时间中的总天数。这基于一天的标准定义为24小时。

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

      返回:
      持续时间中的天数，可能为负数

    • toHours

      public long toHours()
      获取此持续时间中的小时数。

      通过将秒数除以3600来返回持续时间中的总小时数。

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

      返回:
      持续时间中的小时数，可能为负数

    • toMinutes

      public long toMinutes()
      获取此持续时间中的分钟数。

      通过将秒数除以60来返回持续时间中的总分钟数。

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

      返回:
      持续时间中的分钟数，可能为负数

    • toSeconds

      public long toSeconds()
      获取此持续时间中的秒数。

      返回持续时间中的总整秒数。

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

      返回:
      持续时间长度的整秒部分，可能为正数或负数
      自:
      9

    • toMillis

      public long toMillis()
      将此持续时间转换为毫秒中的总长度。

      如果此持续时间太大，无法容纳在long毫秒中，则会抛出异常。

      如果此持续时间的精度大于毫秒，则转换将丢弃任何多余的精度信息，就好像纳秒数按一百万进行整数除法。

      返回:
      持续时间的总长度，以毫秒为单位
      抛出:
      ArithmeticException - 如果发生数值溢出

    • toNanos

      public long toNanos()
      将此持续时间转换为以long表示的纳秒中的总长度。

      如果此持续时间太大，无法容纳在long纳秒中，则会抛出异常。

      返回:
      持续时间的总长度，以纳秒为单位
      抛出:
      ArithmeticException - 如果发生数值溢出

    • toDaysPart

      public long toDaysPart()
      提取持续时间中的天数。

      通过将秒数除以86400来返回持续时间中的总天数。这基于一天的标准定义为24小时。

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

      API注释:
      此方法的行为与toDays()完全相同。
      返回:
      持续时间中的天数，可能为负数
      自:
      9

    • toHoursPart

      public int toHoursPart()
      提取持续时间中的小时部分。

      通过将toHours()除以一天的小时数来返回剩余小时数。这是基于标准定义的一天为24小时。

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

      返回:
      持续时间中的小时部分，可能为负数
      自:
      9

    • toMinutesPart

      public int toMinutesPart()
      提取持续时间中的分钟部分。

      通过将toMinutes()除以一小时的分钟数来返回剩余分钟数。这是基于标准定义的一小时为60分钟。

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

      返回:
      持续时间中的分钟部分，可能为负数
      自:
      9

    • toSecondsPart

      public int toSecondsPart()
      提取持续时间中的秒部分。

      通过将toSeconds()除以一分钟的秒数来返回剩余秒数。这是基于标准定义的一分钟为60秒。

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

      返回:
      持续时间中的秒部分，可能为负数
      自:
      9

    • toMillisPart

      public int toMillisPart()
      提取持续时间中的毫秒部分。

      通过将纳秒数除以1,000,000来返回毫秒部分。持续时间的长度使用两个字段存储 - 秒和纳秒。纳秒部分是一个从0到999,999,999的值，用于调整秒数的长度。总持续时间由调用getNano()和getSeconds()来定义。

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

      返回:
      持续时间中的毫秒部分。
      自:
      9

    • toNanosPart

      public int toNanosPart()
      获取持续时间中秒数内的纳秒部分。

      持续时间的长度使用两个字段存储 - 秒和纳秒。纳秒部分是一个从0到999,999,999的值，用于调整秒数的长度。总持续时间由调用getNano()和getSeconds()来定义。

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

      返回:
      持续时间长度中秒内的纳秒部分，从0到999,999,999
      自:
      9

    • truncatedTo

      public Duration truncatedTo(TemporalUnit unit)
      返回截断为指定单位的此Duration的副本。

      截断持续时间将返回原始持续时间的副本，其中概念字段小于指定单位的部分设置为零。例如，使用MINUTES单位进行截断将向零舍入到最接近的分钟，将秒和纳秒设置为零。

      单位必须具有可被标准天长度整除的持续时间，而不产生余数。这包括所有ChronoUnit上的基于时间的单位和DAYS。其他ChronoUnits会抛出异常。

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

      参数:
      unit - 要截断到的单位，不能为空
      返回:
      基于此持续时间的截断时间的Duration，不能为空
      抛出:
      DateTimeException - 如果单位无效以进行截断
      UnsupportedTemporalTypeException - 如果不支持该单位
      自:
      9

    • compareTo

      public int compareTo(Duration otherDuration)
      将此持续时间与指定的Duration进行比较。

      比较基于持续时间的总长度。它是"与equals一致"的，如Comparable所定义。

      指定者:
      compareTo 在接口 Comparable<Duration>
      参数:
      otherDuration - 要比较的其他持续时间，不能为空
      返回:
      比较器值，如果此持续时间小于otherDuration则小于零，如果相等则为零，如果此持续时间大于otherDuration则大于零

    • equals

      public boolean equals(Object other)
      检查此持续时间是否等于指定的Duration。

      比较基于持续时间的总长度。

      覆盖:
      equals 在类 Object
      参数:
      other - 另一个持续时间，null返回false
      返回:
      如果另一个持续时间等于此持续时间则为true
      参见:

    • hashCode

      public int hashCode()
      此持续时间的哈希码。
      覆盖:
      hashCode 在类 Object
      返回:
      一个适当的哈希码
      参见:

    • toString

      public String toString()
      使用ISO-8601基于秒的表示法返回此持续时间的字符串表示，例如PT8H6M12.345S。

      返回字符串的格式将为PTnHnMnS，其中n是持续时间的相关小时、分钟或秒部分。任何小数秒都放在秒部分的小数点后。如果某部分的值为零，则省略该部分。小时、分钟和秒将具有相同的符号。

      示例：

          "20.345秒"                 -- "PT20.345S
    "15分钟" (15 * 60秒)   -- "PT15M"
    "10小时" (10 * 3600秒)   -- "PT10H"
    "2天" (2 * 86400秒)     -- "PT48H"
      注意，24小时的倍数不会输出为天，以避免与Period混淆。
      覆盖:
      toString 在类 Object
      返回:
      此持续时间的ISO-8601表示，不能为空