All Implemented Interfaces:

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 。

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

实现要求：

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

从以下版本开始：

1.8

另请参见：

Serialized Form

Field Summary

Fields
Modifier and Type	Field	描述
`static Duration`	`ZERO`	持续时间为零的常数。

方法摘要

所有方法静态方法接口方法具体的方法
Modifier and Type	方法	描述
`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()`	返回长度为否定的此持续时间的副本。
`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`表示的总长度，表示为 `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 inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- 字段详细信息
  - ZERO
```
public static final Duration ZERO
```
    持续时间为零的常数。
- 方法详细信息
  - ofDays
```
public static Duration ofDays(long days)
```
    获得Duration代表一些标准的24小时的日子。
    秒是根据一天的标准清晰度计算的，每天的天数为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 ，不为null
    
    异常
    
    ArithmeticException - 如果调整导致秒数超过 Duration的容量
  - ofMillis
```
public static Duration ofMillis(long millis)
```
    获得Duration表示毫秒数。
    从指定的毫秒中提取秒和纳秒。
    
    参数
    
    millis - 毫秒数，正或负数
    
    结果
    
    一个 Duration ，不为null
  - ofNanos
```
public static Duration ofNanos(long nanos)
```
    获得代表数纳秒的Duration 。
    从指定的纳秒提取秒和纳秒。
    
    参数
    
    nanos - 纳秒数，正或负数
    
    结果
    
    一个 Duration ，不为null
  - 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 ，不为null
    
    异常
    
    DateTimeException - 如果周期单位具有估计的持续时间
    
    ArithmeticException - 如果发生数字溢出
  - from
```
public static Duration from(TemporalAmount amount)
```
    从时间量获取Duration的实例。
    这取决于指定量的持续时间。 A 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 。小数点可以是点或逗号。小数部分可能具有从零到九位数。
    
    其他单位的前加/减号和负值不属于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 ，不为null
    
    异常
    
    DateTimeException - 如果无法获得时间之间的秒数
    
    ArithmeticException - 如果计算超过容量 Duration
  - get
```
public long get(TemporalUnit unit)
```
    获取所请求单元的值。
    这将为两个支持的单元SECONDS和NANOS中的每一个返回一个值。所有其他单位抛出异常。
    
    Specified by:
    
    get在接口 TemporalAmount
    
    参数
    
    unit - TemporalUnit返回值的 TemporalUnit
    
    结果
    
    单位的长期价值
    
    异常
    
    DateTimeException - 如果不支持本机
    
    UnsupportedTemporalTypeException - 如果不支持本机
  - getUnits
```
public List<TemporalUnit> getUnits()
```
    获取此持续时间支持的单位集。
    支持的单位为SECONDS和NANOS 。它们按照秒，nanos的顺序返回。
    
    该组可以与get(TemporalUnit)一起使用以访问整个持续时间的状态。
    
    Specified by:
    
    getUnits在接口 TemporalAmount
    
    结果
    
    包含秒和纳米单位的列表，不为空
  - isZero
```
public boolean isZero()
```
    检查此持续时间是否为零长度。
    A Duration表示时间线上两点之间的有向距离，因此可以为正，零或负。该方法检查长度是否为零。
    
    结果
    
    如果此持续时间的总长度等于零，则为真
  - isNegative
```
public boolean isNegative()
```
    检查此持续时间是否为负，不包括零。
    A Duration表示时间线上两点之间的有向距离，因此可以为正，零或负。此方法检查长度是否小于零。
    
    结果
    
    如果此持续时间的总长度小于零，则为真
  - getSeconds
```
public long getSeconds()
```
    获取此持续时间内的秒数。
    使用两个字段（秒和纳秒）存储持续时间的长度。纳秒部分是从0到999,999,999的值，它是以秒为单位的长度的调整。总持续时间通过调用此方法和getNano()来定义。
    
    A Duration表示时间线上两点之间的有向距离。负数持续时间由秒部分的负号表示。 -1纳秒的持续时间存储为-1秒加上999,999,999纳秒。
    
    结果
    
    整个秒的长度部分持续时间为正或负
  - getNano
```
public int getNano()
```
    在此持续时间内获得第二秒内的纳秒数。
    使用两个字段（秒和纳秒）存储持续时间的长度。纳秒部分是从0到999,999,999的值，它是以秒为单位的长度的调整。总持续时间通过调用此方法和getSeconds()来定义。
    
    A Duration表示时间线上两点之间的有向距离。负数持续时间由秒部分的负号表示。 -1纳秒的持续时间存储为-1秒加上999,999,999纳秒。
    
    结果
    
    第二部分的纳秒长度为0到999,999,999
  - withSeconds
```
public Duration withSeconds(long seconds)
```
    以指定的秒数返回此持续时间的副本。
    这将返回指定秒数的持续时间，保留此持续时间的纳秒的部分。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    seconds - 表示秒可以是负数
    
    结果
    
    一个 Duration基于此期间与请求的秒，不为null
  - withNanos
```
public Duration withNanos(int nanoOfSecond)
```
    以指定的纳秒为单位返回此持续时间的副本。
    这将返回具有指定的纳秒的持续时间，保留此持续时间的秒数。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    nanoOfSecond - 表示从0到999,999,999的纳秒
    
    结果
    
    一个 Duration基于这个时期与请求的纳秒，不为null
    
    异常
    
    DateTimeException - 如果纳秒是无效的
  - plus
```
public Duration plus(Duration duration)
```
    返回此持续时间的副本，并添加指定的持续时间。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    duration - 添加的持续时间，正或负，不为空
    
    结果
    
    一个 Duration基于这个持续时间，指定的持续时间加上，不为空
    
    异常
    
    ArithmeticException - 如果发生数字溢出
  - plus
```
public Duration plus(long amountToAdd,
                     TemporalUnit unit)
```
    返回此持续时间的副本，并添加指定的持续时间。
    持续时间量以指定单位计量。这种方法只接受一个单位的子集。单位必须有exact duration或ChronoUnit.DAYS ，被视为24小时。其他单位抛出异常。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    amountToAdd - 添加量，以单位计，正数或负数
    
    unit - 测量金额的单位必须具有精确的持续时间，而不是空值
    
    结果
    
    一个 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基于这个持续时间，加上指定的小时数，不为空
    
    异常
    
    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 - 减去正或负的持续时间，不为空
    
    结果
    
    一个 Duration基于此持续时间减去指定的持续时间，不为null
    
    异常
    
    ArithmeticException - 如果发生数字溢出
  - minus
```
public Duration minus(long amountToSubtract,
                      TemporalUnit unit)
```
    返回指定持续时间的副本减去。
    持续时间量以指定单位计量。这种方法只接受一个单位的子集。单位必须有exact duration或ChronoUnit.DAYS ，被视为24小时。其他单位抛出异常。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    amountToSubtract - 以单位为单位，以正或负值来衡量的量
    
    unit - 测量金额的单位必须具有精确的持续时间，而不是空值
    
    结果
    
    一个 Duration基于此持续时间减去指定的持续时间，不为null
    
    异常
    
    ArithmeticException - 如果发生数字溢出
  - minusDays
```
public Duration minusDays(long daysToSubtract)
```
    在标准的24小时内减去指定的持续时间，返回此持续时间的副本。
    天数乘以86400，以获得要减去的秒数。这是基于一天24小时的标准清晰度。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    daysToSubtract - 减去正数或负数的日期
    
    结果
    
    一个 Duration基于此持续时间减去指定的日期，不为null
    
    异常
    
    ArithmeticException - 如果发生数字溢出
  - minusHours
```
public Duration minusHours(long hoursToSubtract)
```
    以缩小的小时返回指定持续时间的此持续时间的副本。
    小时数乘以3600，以获得要减去的秒数。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    hoursToSubtract - 减去正数或负数的小时数
    
    结果
    
    一个 Duration基于此持续时间减去指定的小时，不为空
    
    异常
    
    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基于此持续时间减去指定的毫秒，不为空
    
    异常
    
    ArithmeticException - 如果发生数字溢出
  - minusNanos
```
public Duration minusNanos(long nanosToSubtract)
```
    以指定的持续时间返回此持续时间的副本，减去纳秒。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    nanosToSubtract - 减去正数或负数的纳秒
    
    结果
    
    一个 Duration基于此持续时间减去指定的纳秒，不为空
    
    异常
    
    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)来更正呼叫模式。
    
    // these two lines are equivalent, but the second approach is recommended dateTime = thisDuration.addTo(dateTime); dateTime = dateTime.plus(thisDuration);
    
    计算将添加秒，然后添加纳秒。只会增加非零金额。
    
    此实例是不可变的，不受此方法调用的影响。
    Specified by:
    
    addTo在接口 TemporalAmount
    
    参数
    
    temporal - 要调整的时间对象，不为空
    
    结果
    
    与调整相同类型的对象，不为空
    
    异常
    
    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在接口 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 ，分为标准日期的长度，不含余量。这包括所有提供的时间单位ChronoUnit和DAYS 。其他ChronoUnits会抛出异常。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    unit - 截断到的单位，不为null
    
    结果
    
    一个 Duration基于此持续时间截断，不为null
    
    异常
    
    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
    
    结果
    
    如果其他持续时间等于这一个则为真
    
    另请参见：
    
    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

Field Summary

方法摘要

Methods inherited from class 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