实现的所有接口

Serializable ， Comparable<Duration> ， TemporalAmount
```
public final class Durationextends Objectimplements TemporalAmount, Comparable<Duration>, Serializable
```
基于时间的时间量，例如'34.5秒'。
此类以秒和纳秒为单位模拟时间量或时间量。可以使用其他基于持续时间的单位访问它，例如分钟和小时。此外， DAYS单元可以使用，并且被视为完全等于24小时，因此忽略了夏令时效果。有关此类的基于日期的等效项，请参阅Period 。

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

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

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

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

实现要求：

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

从以下版本开始：

1.8

另请参见：

Serialized Form

字段汇总

字段
变量和类型	字段	描述
`static Duration`	`ZERO`	持续时间为零。

方法摘要

所有方法静态方法实例方法具体的方法
变量和类型	方法	描述
`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 otherDuration)`	检查此持续时间是否等于指定的 `Duration` 。
`static Duration`	`from(TemporalAmount amount)`	从时间量获得 `Duration`的实例。
`long`	`get(TemporalUnit unit)`	获取所请求单元的值。
`int`	`getNano()`	获取此持续时间内秒数内的纳秒数。
`long`	`getSeconds()`	获取此持续时间内的秒数。
`List<TemporalUnit>`	`getUnits()`	获取此持续时间支持的单位集。
`int`	`hashCode()`	此持续时间的哈希码。
`boolean`	`isNegative()`	检查此持续时间是否为负，不包括零。
`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()`	返回此持续时间的副本，其长度为negated。
`static Duration`	`of(long amount, TemporalUnit unit)`	获得 `Duration`表示指定单位的金额。
`static Duration`	`ofDays(long days)`	获得 `Duration`代表多个标准24小时工作日。
`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)`	获得 `Duration`从文本字符串，如 `PnDTnHnMn.nS` 。
`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)`	以指定的秒数返回此持续时间的副本。

声明方法的类 java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- 字段详细信息
  - ZERO
```
public static final Duration ZERO
```
    持续时间为零。
- 方法详细信息
  - ofDays
```
public static Duration ofDays(long days)
```
    获得代表多个标准24小时工作日的Duration 。
    秒数是根据一天的标准定义计算的，其中每天是86400秒，这意味着每天24小时。第二场中的纳秒设置为零。
    
    参数
    
    days - 天数，正面或负面
    
    结果
    
    Duration ，非空
    
    异常
    
    ArithmeticException - 如果输入天数超过容量 Duration
  - ofHours
```
public static Duration ofHours(long hours)
```
    获得代表若干标准小时数的Duration 。
    秒数基于一小时的标准定义计算，其中每小时为3600秒。第二场中的纳秒设置为零。
    
    参数
    
    hours - 正面或负面的小时数
    
    结果
    
    Duration ，非空
    
    异常
    
    ArithmeticException - 如果输入小时数超过容量 Duration
  - ofMinutes
```
public static Duration ofMinutes(long minutes)
```
    获得代表若干标准分钟的Duration 。
    秒数基于分钟的标准定义计算，其中每分钟为60秒。第二场中的纳秒设置为零。
    
    参数
    
    minutes - 分钟数，正数或负数
    
    结果
    
    Duration ，非空
    
    异常
    
    ArithmeticException - 如果输入分钟超过容量 Duration
  - ofSeconds
```
public static Duration ofSeconds(long seconds)
```
    获得表示若干秒的Duration 。
    第二场中的纳秒设置为零。
    
    参数
    
    seconds - 秒数，正数或负数
    
    结果
    
    Duration ，非空
  - 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);
    此方法仅接受单位的子集。该单位必须具有exact duration或ChronoUnit.DAYS ，其被视为24小时。其他单位抛出异常。
    参数
    
    amount - 持续时间的数量，以单位，正数或负数衡量
    
    unit - 测量持续时间的单位必须具有确切的持续时间，而不是空
    
    结果
    
    Duration ，非空
    
    异常
    
    DateTimeException - 如果期间单位具有估计持续时间
    
    ArithmeticException - 如果发生数字溢出
  - from
```
public static Duration from(TemporalAmount amount)
```
    从时间量获得Duration的实例。
    这将根据指定的金额获得持续时间。 TemporalAmount表示该工厂提取到持续时间的时间量，其可以是基于日期的或基于时间的。
    
    转换从金额围绕单位集循环，并使用单位的duration来计算总计Duration 。此方法仅接受单位的子集。该单元必须具有exact duration或ChronoUnit.DAYS ，其被视为24小时。如果找到任何其他单位，则抛出异常。
    
    参数
    
    amount - 要转换的时间量，不为空
    
    结果
    
    等效的持续时间，不为空
    
    异常
    
    DateTimeException - 如无法兑换成 Duration
    
    ArithmeticException - 如果发生数字溢出
  - parse
```
public static Duration parse(CharSequence text)
```
    获得Duration从文本字符串，如PnDTnHnMn.nS 。
    这将解析持续时间的文本表示，包括由toString()生成的字符串。接受的格式基于ISO-8601持续时间格式PnDTnHnMn.nS ，天数被认为是24小时。
    
    该字符串以可选符号开头，由ASCII否定符号或正符号表示。如果是否定的，整个时期都会被否定。 ASCII字母“P”接下来是大写或小写。然后有四个部分，每个部分由数字和后缀组成。这些部分的ASCII为“D”，“H”，“M”和“S”的后缀为天，小时，分钟和秒，以大写或小写形式接受。后缀必须按顺序出现。 ASCII字母“T”必须出现在第一次出现（如果有）小时，分钟或秒节之前。必须存在四个部分中的至少一个，并且如果存在“T”，则在“T”之后必须存在至少一个部分。每个部分的数字部分必须包含一个或多个ASCII数字。该数字可以以ASCII否定符号或正符号作为前缀。天数，小时数和分钟数必须解析为long 。必须使用可选分数解析为long的秒数。小数点可以是点或逗号。小数部分可以具有从0到9的数字。
    
    前导加号/减号以及其他单位的负值不属于ISO-8601标准。
    
    例子：
    
    "PT20.345S" -- parses as "20.345 seconds" "PT15M" -- parses as "15 minutes" (where a minute is 60 seconds) "PT10H" -- parses as "10 hours" (where an hour is 3600 seconds) "P2D" -- parses as "2 days" (where a day is 24 hours or 86400 seconds) "P2DT3H4M" -- parses as "2 days, 3 hours and 4 minutes" "PT-6H3M" -- parses as "-6 hours and +3 minutes" "-PT6H3M" -- parses as "-6 hours and -3 minutes" "-PT-6H+3M" -- parses as "+6 hours and -3 minutes"
    参数
    
    text - 要解析的文本，而不是null
    
    结果
    
    解析的持续时间，不为空
    
    异常
    
    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中的每一个的值。所有其他单位都抛出异常。
    
    Specified by:
    
    get ，界面 TemporalAmount
    
    参数
    
    unit - 要为其返回值的 TemporalUnit
    
    结果
    
    单位的长期价值
    
    异常
    
    DateTimeException - 如果不支持该装置
    
    UnsupportedTemporalTypeException - 如果不支持该装置
  - getUnits
```
public List<TemporalUnit> getUnits()
```
    获取此持续时间支持的单位集。
    支持的单位是SECONDS和NANOS 。它们按秒纳米的顺序返回。
    
    此组可与get(TemporalUnit)结合使用以访问持续时间的整个状态。
    
    Specified by:
    
    getUnits接口 TemporalAmount
    
    结果
    
    包含秒和纳米单位的列表，不为空
  - 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 - 表示的秒数，可能是负数
    
    结果
    
    基于此期间的 Duration请求的秒数，不为空
  - withNanos
```
public Duration withNanos(int nanoOfSecond)
```
    使用指定的纳秒数返回此持续时间的副本。
    这将返回指定的纳秒数的持续时间，保留此持续时间的秒部分。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    nanoOfSecond - 代表的纳秒数，从0到999,999,999
    
    结果
    
    基于此期间的 Duration ，请求的纳秒数，不为空
    
    异常
    
    DateTimeException - 如果纳秒级无效
  - plus
```
public Duration plus(Duration duration)
```
    返回此持续时间的副本，并添加指定的持续时间。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    duration - 要添加的持续时间，正数或负数，不为空
    
    结果
    
    基于此持续时间的 Duration ，添加了指定的持续时间，而不是null
    
    异常
    
    ArithmeticException - 如果发生数字溢出
  - plus
```
public Duration plus(long amountToAdd,                     TemporalUnit unit)
```
    返回此持续时间的副本，并添加指定的持续时间。
    持续时间金额以指定单位计量。此方法仅接受单位的子集。该单元必须具有exact duration或ChronoUnit.DAYS ，其被视为24小时。其他单位抛出异常。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    amountToAdd - 要添加的金额，以单位表示，正面或负面
    
    unit - 计量金额的单位必须具有确切的持续时间，而不是空
    
    结果
    
    a Duration基于此持续时间并添加了指定的持续时间，而不是null
    
    异常
    
    UnsupportedTemporalTypeException - 如果不支持该装置
    
    ArithmeticException - 如果发生数字溢出
  - plusDays
```
public Duration plusDays(long daysToAdd)
```
    返回此持续时间的副本，并在标准的24小时内添加指定的持续时间。
    将天数乘以86400以获得要添加的秒数。这是基于24小时的标准定义。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    daysToAdd - 添加的日期，正面或负面
    
    结果
    
    基于此持续时间的 Duration ，添加了指定的天数，而不是null
    
    异常
    
    ArithmeticException - 如果发生数字溢出
  - plusHours
```
public Duration plusHours(long hoursToAdd)
```
    返回此持续时间的副本，并指定持续时间（以小时为单位）。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    hoursToAdd - 要添加的小时数，正面或负面
    
    结果
    
    基于此持续时间的 Duration ，添加了指定的小时数，而不是null
    
    异常
    
    ArithmeticException - 如果发生数字溢出
  - plusMinutes
```
public Duration plusMinutes(long minutesToAdd)
```
    返回此持续时间的副本，并添加指定的持续时间（分钟）。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    minutesToAdd - 要添加的分钟数，正数或负数
    
    结果
    
    基于此持续时间的 Duration ，添加了指定的分钟，而不是null
    
    异常
    
    ArithmeticException - 如果发生数字溢出
  - plusSeconds
```
public Duration plusSeconds(long secondsToAdd)
```
    返回此持续时间的副本，并添加指定的持续时间（以秒为单位）
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    secondsToAdd - 添加的秒数，正数或负数
    
    结果
    
    基于此持续时间的 Duration ，添加了指定的秒数，而不是null
    
    异常
    
    ArithmeticException - 如果发生数字溢出
  - plusMillis
```
public Duration plusMillis(long millisToAdd)
```
    返回此持续时间的副本，其中包含指定的持续时间（以毫秒为单位）。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    millisToAdd - 要添加的毫秒数，正数或负数
    
    结果
    
    基于此持续时间的 Duration ，添加了指定的毫秒数，而不是null
    
    异常
    
    ArithmeticException - 如果发生数字溢出
  - plusNanos
```
public Duration plusNanos(long nanosToAdd)
```
    返回此持续时间的副本，并添加指定的持续时间（以纳秒为单位）。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    nanosToAdd - 要添加的纳秒数，正数或负数
    
    结果
    
    基于此持续时间的 Duration ，添加了指定的纳秒，不为空
    
    异常
    
    ArithmeticException - 如果发生数字溢出
  - minus
```
public Duration minus(Duration duration)
```
    返回此持续时间的副本，并减去指定的持续时间。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    duration - 减去的持续时间，正数或负数，不为空
    
    结果
    
    a Duration基于此持续时间减去指定的持续时间，不为空
    
    异常
    
    ArithmeticException - 如果发生数字溢出
  - minus
```
public Duration minus(long amountToSubtract,                      TemporalUnit unit)
```
    返回此持续时间的副本，并减去指定的持续时间。
    持续时间金额以指定单位计量。此方法仅接受单位的子集。该单元必须具有exact duration或ChronoUnit.DAYS ，其被视为24小时。其他单位抛出异常。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    amountToSubtract - 减去的数量，以单位，正数或负数衡量
    
    unit - 计量金额的单位必须具有确切的持续时间，而不是空
    
    结果
    
    a Duration基于此持续时间减去指定的持续时间，不为空
    
    异常
    
    ArithmeticException - 如果发生数字溢出
  - minusDays
```
public Duration minusDays(long daysToSubtract)
```
    返回此持续时间的副本，并在标准的24小时内减去指定的持续时间。
    将天数乘以86400以获得减去的秒数。这是基于24小时的标准定义。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    daysToSubtract - 减去，正面或负面的日子
    
    结果
    
    a Duration基于此持续时间减去指定天数，不为空
    
    异常
    
    ArithmeticException - 如果发生数字溢出
  - minusHours
```
public Duration minusHours(long hoursToSubtract)
```
    返回此持续时间的副本，并减去指定的持续时间（以小时为单位）。
    小时数乘以3600以获得减去的秒数。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    hoursToSubtract - 减去的小时数，正数或负数
    
    结果
    
    基于此持续时间的 Duration ，减去指定的小时数，不为空
    
    异常
    
    ArithmeticException - 如果发生数字溢出
  - minusMinutes
```
public Duration minusMinutes(long minutesToSubtract)
```
    返回此持续时间的副本，并减去指定的持续时间（以分钟为单位）。
    小时数乘以60以获得减去的秒数。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    minutesToSubtract - 减去 minutesToSubtract ，正数或负数
    
    结果
    
    基于此持续时间的 Duration ，减去指定的分钟数，不为空
    
    异常
    
    ArithmeticException - 如果发生数字溢出
  - minusSeconds
```
public Duration minusSeconds(long secondsToSubtract)
```
    返回此持续时间的副本，并减去指定的持续时间（以秒为单位）。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    secondsToSubtract - 减去秒数，正数或负数
    
    结果
    
    a Duration基于此持续时间减去指定的秒数，不为空
    
    异常
    
    ArithmeticException - 如果发生数字溢出
  - minusMillis
```
public Duration minusMillis(long millisToSubtract)
```
    返回此持续时间的副本，并减去指定的持续时间（以毫秒为单位）。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    millisToSubtract - 减去的毫秒数，正数或负数
    
    结果
    
    基于此持续时间的 Duration ，减去指定的毫秒数，不为空
    
    异常
    
    ArithmeticException - 如果发生数字溢出
  - minusNanos
```
public Duration minusNanos(long nanosToSubtract)
```
    返回此持续时间的副本，并减去指定的持续时间（以纳秒为单位）。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    nanosToSubtract - 减去纳秒，正或负
    
    结果
    
    基于此持续时间的 Duration减去指定的纳秒，而不是空
    
    异常
    
    ArithmeticException - 如果发生数字溢出
  - multipliedBy
```
public Duration multipliedBy(long multiplicand)
```
    返回此持续时间的副本乘以标量。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    multiplicand - 将持续时间乘以正数或负数的值
    
    结果
    
    a Duration基于此持续时间乘以指定的标量，而不是null
    
    异常
    
    ArithmeticException - 如果发生数字溢出
  - dividedBy
```
public Duration dividedBy(long divisor)
```
    返回此持续时间的副本除以指定的值。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    divisor - 将持续时间除以正数或负数而不是零的值
    
    结果
    
    a Duration基于此持续时间除以指定的除数，不为空
    
    异常
    
    ArithmeticException - 如果除数为零或发生数值溢出
  - dividedBy
```
public long dividedBy(Duration divisor)
```
    返回指定持续时间在此持续时间内发生的整数次数。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    divisor - 将持续时间除以正数或负数的值，不为空
    
    结果
    
    整数次，舍入为零，在此持续时间内发生指定的 Duration ，可能为负数
    
    异常
    
    ArithmeticException - 如果除数为零，或者发生数值溢出
    
    从以下版本开始：
    
    9
  - negated
```
public Duration negated()
```
    返回此持续时间的副本，其长度为negated。
    此方法交换此持续时间总长度的符号。例如， PT1.3S将作为PT-1.3S返回。
    
    此实例是不可变的，不受此方法调用的影响。
    
    结果
    
    基于此持续时间的 Duration ，金额为否定，不为空
    
    异常
    
    ArithmeticException - 如果发生数字溢出
  - abs
```
public Duration abs()
```
    返回此持续时间的副本，长度为正。
    此方法通过有效地从任何负总长度中删除符号来返回正持续时间。例如， PT-1.3S将作为PT1.3S返回。
    
    此实例是不可变的，不受此方法调用的影响。
    
    结果
    
    基于此持续时间的 Duration ，绝对长度，不为空
    
    异常
    
    ArithmeticException - 如果发生数字溢出
  - addTo
```
public Temporal addTo(Temporal temporal)
```
    将此持续时间添加到指定的时态对象。
    这将返回与添加了此持续时间的输入相同的可观察类型的时间对象。
    
    在大多数情况下，使用Temporal.plus(TemporalAmount)更清楚地反转调用模式。
    
    // these two lines are equivalent, but the second approach is recommended dateTime = thisDuration.addTo(dateTime); dateTime = dateTime.plus(thisDuration);
    
    计算将添加秒，然后纳米。仅添加非零金额。
    
    此实例是不可变的，不受此方法调用的影响。
    Specified by:
    
    addTo在界面 TemporalAmount
    
    参数
    
    temporal - 要调整的时态对象，而不是null
    
    结果
    
    进行调整的相同类型的对象，不为空
    
    异常
    
    DateTimeException - 如果无法添加
    
    ArithmeticException - 如果发生数字溢出
  - subtractFrom
```
public Temporal subtractFrom(Temporal temporal)
```
    从指定的时态对象中减去此持续时间。
    这将返回与输入相同的可观察类型的时间对象，并减去此持续时间。
    
    在大多数情况下，使用Temporal.minus(TemporalAmount)更清楚地反转调用模式。
    
    // these two lines are equivalent, but the second approach is recommended dateTime = thisDuration.subtractFrom(dateTime); dateTime = dateTime.minus(thisDuration);
    
    计算将减去秒，然后减去纳米。仅添加非零金额。
    
    此实例是不可变的，不受此方法调用的影响。
    Specified by:
    
    subtractFrom in interface TemporalAmount
    
    参数
    
    temporal - 要调整的时态对象，而不是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小时。
    
    此实例是不可变的，不受此方法调用的影响。
    
    结果
    
    持续时间内的天数可能是负数
    
    从以下版本开始：
    
    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单位截断将向下舍入为零到最接近的分钟，将秒和纳秒设置为零。
    
    该单位必须有一个duration ，分为标准日的长度，没有余数。这包括所有time-based units on {@code ChronoUnit}和DAYS 。其他ChronoUnits抛出异常。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    unit - 要截断的单位，而不是null
    
    结果
    
    基于此持续时间的 Duration ，截断时间，不为空
    
    异常
    
    DateTimeException - 如果单位对于截断无效
    
    UnsupportedTemporalTypeException - 如果不支持该设备
    
    从以下版本开始：
    
    9
  - compareTo
```
public int compareTo(Duration otherDuration)
```
    将此持续时间与指定的Duration 。
    比较基于持续时间的总长度。它与“等于”一致，如Comparable所定义。
    
    Specified by:
    
    compareTo在界面 Comparable<Duration>
    
    参数
    
    otherDuration - 要比较的其他持续时间，而不是null
    
    结果
    
    比较器值，如果更小则为负，如果更大则为正
  - equals
```
public boolean equals(Object otherDuration)
```
    检查此持续时间是否等于指定的Duration 。
    比较基于持续时间的总长度。
    
    重写：
    
    equals在课程 Object
    
    参数
    
    otherDuration - 另一个持续时间，null返回false
    
    结果
    
    如果另一个持续时间等于这个，则为true
    
    另请参见：
    
    Object.hashCode() ， HashMap
  - hashCode
```
public int hashCode()
```
    此持续时间的哈希码。
    
    重写：
    
    hashCode在课程 Object
    
    结果
    
    合适的哈希码
    
    另请参见：
    
    Object.equals(java.lang.Object) ， System.identityHashCode(java.lang.Object)
  - toString
```
public String toString()
```
    使用基于ISO-8601秒的表示形式的此持续时间的字符串表示形式，例如PT8H6M12.345S 。
    返回字符串的格式为PTnHnMnS ，其中n是持续时间的相关小时，分钟或秒。在秒节中的小数点后面放置任何小数秒。如果某个部分的值为零，则省略该部分。小时，分钟和秒都将具有相同的符号。
    
    例子：
    
    "20.345 seconds" -- "PT20.345S "15 minutes" (15 * 60 seconds) -- "PT15M" "10 hours" (10 * 3600 seconds) -- "PT10H" "2 days" (2 * 86400 seconds) -- "PT48H"
    请注意，24小时的倍数不会作为天数输出，以避免与Period混淆。
    重写：
    
    toString在课程 Object
    
    结果
    
    此持续时间的ISO-8601表示，不为空

Class Duration

字段汇总

方法摘要

声明方法的类 java.lang.Object

字段详细信息

ZERO

方法详细信息

ofDays

ofHours

ofMinutes

ofSeconds

ofSeconds

ofMillis

ofNanos

of

from

parse

between

get

getUnits

isZero

isNegative

getSeconds

getNano

withSeconds

withNanos

plus

plus

plusDays

plusHours

plusMinutes

plusSeconds

plusMillis

plusNanos

minus

minus

minusDays

minusHours

minusMinutes

minusSeconds

minusMillis

minusNanos

multipliedBy

dividedBy

dividedBy

negated

abs

addTo

subtractFrom

toDays

toHours

toMinutes

toSeconds

toMillis

toNanos

toDaysPart

toHoursPart

toMinutesPart

toSecondsPart

toMillisPart

toNanosPart

truncatedTo

compareTo

equals

hashCode

toString