Duration (Java Platform SE 8 )

java.lang.Object
- java.time.Duration

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和999999999之间。该模型是一个有向的持续时间，这意味着持续时间可能是负的。

持续时间测量在“秒”，但这些不一定是相同的科学“硅第二”的定义，基于原子钟。这种差异只影响持续时间测量的飞跃，第二，不应该影响大多数应用。看到一个讨论作为第二和时间尺度的意义Instant。

这是一个value-based类；利用身份敏感的操作（包括引用相等（==），身份的哈希代码，或同步）的实例Duration可能有不可预知的结果应该是可以避免的。的equals法进行比较。

实现要求：

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

从以下版本开始：

一点八

另请参见：

Serialized Form

Field Summary

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

方法摘要

所有方法静态方法接口方法具体的方法
Modifier and Type	Method and Description
`Duration`	`abs()` 返回此持续时间的一个正长度的副本。
`Temporal`	`addTo(Temporal temporal)` 将此持续时间添加到指定的时间对象。
`static Duration`	`between(Temporal startInclusive, Temporal endExclusive)` 获得 `Duration`表示两个时间对象之间的时间。
`int`	`compareTo(Duration otherDuration)` 比较这个时间到指定的 `Duration`。
`Duration`	`dividedBy(long 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(Duration duration)` 返回此持续时间的副本，用指定的持续时间减去。
`Duration`	`minus(long amountToSubtract, TemporalUnit unit)` 返回此持续时间的副本，用指定的持续时间减去。
`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)` 从一个文本字符串，如 `PnDTnHnMn.nS`一 `Duration`。
`Duration`	`plus(Duration duration)` 返回此持续时间的副本，添加指定的持续时间。
`Duration`	`plus(long amountToAdd, TemporalUnit unit)` 返回此持续时间的副本，添加指定的持续时间。
`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`	`toHours()` 获取在此期间的几个小时数。
`long`	`toMillis()` 将此持续时间转换为毫秒内的总长度。
`long`	`toMinutes()` 获取在此期间的分钟数。
`long`	`toNanos()` 将这个时间的总长度来表示为一个 `long`。
`String`	`toString()` 本期使用ISO-8601秒表示的字符串表示，如 `PT8H6M12.345S`。
`Duration`	`withNanos(int nanoOfSecond)` 返回此持续时间的一个副本与指定的第二个。
`Duration`	`withSeconds(long seconds)` 用指定的秒数返回此持续时间的一个副本。

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Field Detail
  - ZERO
```
public static final Duration ZERO
```
    常数为零的持续时间。
- 方法详细信息
  - ofDays
```
public static Duration ofDays(long days)
```
    获得 Duration代表一些标准的24小时。
    根据标准定义的一天，每天都是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至999999999范围内。例如，以下将导致完全相同的持续时间：
```
时间秒（3、1）；时间。秒（4，- 999_999_999）；持续时间（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小时”。例如:
```
持续时间（3，秒）；持续时间（465，小时）；
```
    只有一部分单位都用这种方式接受。单位必须有一个 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)
```
    从一个文本字符串，如 PnDTnHnMn.nS一 Duration。
    这一时间将解析的文本表示形式，包括由toString()字符串的格式。接受是基于时间与天PnDTnHnMn.nS ISO-8601格式被认为是24个小时。
    
    字符串的开始与一个可选的标志，以ASCII或正或负的符号表示。如果为负，整个时期被否定。ASCII字母“P”是大写或小写下。然后有四个部分，每一个由一个数字和一个后缀组成。部分后缀“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分钟”“p-6h3m”解析为“6小时和3分钟”“p6h3m”解析为“6小时3分钟”“p-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。所有其他单位抛出一个异常。
    
    Specified by:
    
    get 接口 TemporalAmount
    
    参数
    
    unit -其中 TemporalUnit返回值
    
    结果
    
    单位的长值
    
    异常
    
    DateTimeException如果单位不支持
    
    UnsupportedTemporalTypeException如果单位不支持
  - getUnits
```
public List<TemporalUnit> getUnits()
```
    获取此持续时间所支持的单位集。
    支持单位SECONDS，和NANOS。他们是在以秒回来，Nano。
    
    这套可结合使用get(TemporalUnit)访问期间整个国家。
    
    Specified by:
    
    getUnits 接口 TemporalAmount
    
    结果
    
    包含一个列表的秒和Nano的单位，不为空
  - isZero
```
public boolean isZero()
```
    检查此持续时间是否为零的长度。
    一个Duration表示一个有向距离上的两点之间的时间线，因此可以正、零或负。这种方法检查长度是否为零。
    
    结果
    
    如果这个持续时间有一个总长度等于零
  - isNegative
```
public boolean isNegative()
```
    检查此持续时间是否为负，不包括零。
    一个Duration表示一个有向距离上的两点之间的时间线，因此可以正、零或负。这种方法检查长度是否小于零。
    
    结果
    
    如果这个持续时间有一个总长度小于零
  - getSeconds
```
public long getSeconds()
```
    获取在此期间的秒数。
    时间的长度是使用两个领域-秒和纳秒存储。纳秒部分是从0到999999999的值是在秒的长度调整。总时间是通过调用此方法，getNano()定义。
    
    一个Duration表示一个有向距离在时间线上两点之间。负的持续时间是由秒部分的负符号表示的。持续时间为1纳秒存储为1秒加999999999纳秒。
    
    结果
    
    整个秒的一部分长度的持续时间，正面或负面的
  - getNano
```
public int getNano()
```
    得到的纳秒数在第二在这个时间。
    时间的长度是使用两个领域-秒和纳秒存储。纳秒部分是从0到999999999的值是在秒的长度调整。总时间是通过调用此方法，getSeconds()定义。
    
    一个Duration表示一个有向距离在时间线上两点之间。负的持续时间是由秒部分的负符号表示的。持续时间为1纳秒存储为1秒加999999999纳秒。
    
    结果
    
    对时间长度的第二部分在纳秒级，从0到999999999
  - withSeconds
```
public Duration withSeconds(long seconds)
```
    用指定的秒数返回此持续时间的一个副本。
    这将返回一个持续时间与指定的秒，保持这个持续时间的第二部分的纳米。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    seconds -代表秒，可能是负面的
    
    结果
    
    一个 Duration基于这一时期与请求的秒，不空
  - withNanos
```
public Duration withNanos(int nanoOfSecond)
```
    返回此持续时间的一个副本与指定的第二个。
    这将返回一个持续时间与指定的第二，保留了这一持续时间的一部分。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    nanoOfSecond -二代表纳米，从0到999999999
    
    结果
    
    基于这一 Duration期与第二请求纳米，不空
    
    异常
    
    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时间与指定的持续时间增加，不为空
    
    异常
    
    UnsupportedTemporalTypeException如果单位不支持
    
    ArithmeticException如果数值溢出时
  - plusDays
```
public Duration plusDays(long daysToAdd)
```
    返回此持续时间的一个副本，在标准的24小时天添加指定的时间。
    天数乘以86400，以获得秒数。这是基于一天的标准定义为24小时。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    daysToAdd -加天，阳性或阴性
    
    结果
    
    用指定的天添加在这个时间 Duration为主，不为空
    
    异常
    
    ArithmeticException如果数值溢出时
  - plusHours
```
public Duration plusHours(long hoursToAdd)
```
    返回此持续时间的一个副本，在指定的时间内添加。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    hoursToAdd -加小时，阳性或阴性
    
    结果
    
    用指定的时间加上这个时间 Duration为主，不为空
    
    异常
    
    ArithmeticException如果数值溢出时
  - plusMinutes
```
public Duration plusMinutes(long minutesToAdd)
```
    返回此持续时间的一个副本，在指定的时间内添加。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    minutesToAdd -加分钟，阳性或阴性
    
    结果
    
    用指定的分钟加上这个时间 Duration为主，不为空
    
    异常
    
    ArithmeticException如果数值溢出时
  - plusSeconds
```
public Duration plusSeconds(long secondsToAdd)
```
    返回此持续时间的一个副本，在指定的持续时间内添加。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    secondsToAdd -加秒，阳性或阴性
    
    结果
    
    用指定的秒加在这个时间 Duration为主，不为空
    
    异常
    
    ArithmeticException如果数值溢出时
  - plusMillis
```
public Duration plusMillis(long millisToAdd)
```
    返回此持续时间的一个副本，以指定的持续时间在毫秒添加。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    millisToAdd -添加毫秒，阳性或阴性
    
    结果
    
    基于这一 Duration与指定的毫秒时间增加，不为空
    
    异常
    
    ArithmeticException如果数值溢出时
  - plusNanos
```
public Duration plusNanos(long nanosToAdd)
```
    返回一份这个时间在纳秒指定持续时间增加。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    nanosToAdd -添加纳秒，阳性或阴性
    
    结果
    
    基于这一 Duration时间与指定的纳秒补充道，不空
    
    异常
    
    ArithmeticException如果数值溢出时
  - minus
```
public Duration minus(Duration duration)
```
    返回此持续时间的副本，用指定的持续时间减去。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    duration -时间减去的，是积极的还是消极的，不是空的
    
    结果
    
    用指定的时间减去这个时间 Duration为主，不为空
    
    异常
    
    ArithmeticException如果数值溢出时
  - minus
```
public Duration minus(long amountToSubtract,
                      TemporalUnit unit)
```
    返回此持续时间的副本，用指定的持续时间减去。
    持续时间量以指定单位测量。只有一个子集的单位接受这种方法。单位必须有一个exact duration或ChronoUnit.DAYS作为24小时。其他单位抛出一个异常。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    amountToSubtract -月经量，以单位来衡量的，积极的或消极的
    
    unit -单位时间测量，必须有一个确切的时间，没有空
    
    结果
    
    用指定的时间减去这个时间 Duration为主，不为空
    
    异常
    
    ArithmeticException如果数值溢出时
  - minusDays
```
public Duration minusDays(long daysToSubtract)
```
    返回此持续时间的一个副本，在标准的24小时内减去指定的时间。
    天数乘以86400，以获得秒数减去。这是基于一天的标准定义为24小时。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    daysToSubtract -减去天，阳性或阴性
    
    结果
    
    用指定的天数减去这个时间 Duration为主，不为空
    
    异常
    
    ArithmeticException如果数值溢出时
  - minusHours
```
public Duration minusHours(long hoursToSubtract)
```
    返回此持续时间的一个副本，用指定的时间减去。
    小时数乘以3600，以获得秒数减去。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    hoursToSubtract -减小时，阳性或阴性
    
    结果
    
    用指定的时间减去这个时间 Duration为主，不为空
    
    异常
    
    ArithmeticException如果数值溢出时
  - minusMinutes
```
public Duration minusMinutes(long minutesToSubtract)
```
    返回此持续时间的一个副本，在指定的时间内减去。
    小时数乘以60，以获得秒数减去。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    minutesToSubtract -减去分钟，阳性或阴性
    
    结果
    
    用指定的时间减去这个时间 Duration为主，不为空
    
    异常
    
    ArithmeticException如果数值溢出时
  - minusSeconds
```
public Duration minusSeconds(long secondsToSubtract)
```
    返回此持续时间的一个副本，用指定的持续时间减去。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    secondsToSubtract -减去秒，阳性或阴性
    
    结果
    
    用指定的秒中减去这个时间 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 -倍增时间的价值，积极的或消极的
    
    结果
    
    基于这一 Duration时间乘以指定的标量，不空
    
    异常
    
    ArithmeticException如果数值溢出时
  - dividedBy
```
public Duration dividedBy(long divisor)
```
    返回按指定值除以该持续时间的副本。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    divisor -分时间的价值，是积极的还是消极的，不为零
    
    结果
    
    基于这一 Duration时间除以指定的因子，不空
    
    异常
    
    ArithmeticException如果除数为零或者数值溢出时
  - negated
```
public Duration 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)反向调用模式。
```
这两条线是等价的，但第二种方法是建议日期时间= thisduration补充（日期）；日期时间=日期。加（thisduration）；
```
    计算将增加秒，然后纳米。只有非零的金额将被添加。
    
    此实例是不可变的，不受此方法调用的影响。
    Specified by:
    
    addTo 接口 TemporalAmount
    
    参数
    
    temporal -调整时间的对象，不为空
    
    结果
    
    同一类型的对象与所作的调整，而不是空
    
    异常
    
    DateTimeException如果无法添加
    
    ArithmeticException如果数值溢出时
  - subtractFrom
```
public Temporal subtractFrom(Temporal temporal)
```
    从指定的时空对象中减去这个时间。
    这将返回一个相同的可观察类型的时间对象作为输入，这个持续时间减去。
    
    在大多数情况下，更清晰的用Temporal.minus(TemporalAmount)反向调用模式。
```
这两条线是等价的，但第二种方法是建议日期时间= thisduration减去（日期）；日期时间=日期减去（thisduration）；
```
    计算将减秒，然后纳米。只有非零的金额将被添加。
    
    此实例是不可变的，不受此方法调用的影响。
    Specified by:
    
    subtractFrom 接口 TemporalAmount
    
    参数
    
    temporal -调整时间的对象，不为空
    
    结果
    
    同一类型的对象与所作的调整，而不是空
    
    异常
    
    DateTimeException如果不能减
    
    ArithmeticException如果数值溢出时
  - toDays
```
public long toDays()
```
    获取在此期间的天数。
    这将返回在持续时间除以秒数的总数的86400。这是基于一天的标准定义为24小时。
    
    此实例是不可变的，不受此方法调用的影响。
    
    结果
    
    的天数在持续时间，可能是负的
  - toHours
```
public long toHours()
```
    获取在此期间的几个小时数。
    这将返回在持续时间除以秒数的总数的3600。
    
    此实例是不可变的，不受此方法调用的影响。
    
    结果
    
    在持续时间的数小时，可能是负的
  - toMinutes
```
public long toMinutes()
```
    获取在此期间的分钟数。
    这返回在持续时间除以秒数除以60的总分钟数。
    
    此实例是不可变的，不受此方法调用的影响。
    
    结果
    
    在持续时间内的分钟数，可能是负的
  - toMillis
```
public long toMillis()
```
    将此持续时间转换为毫秒内的总长度。
    如果这个时间太大了long毫秒，然后抛出一个异常。
    
    如果这个时间大于毫秒级精度，然后转换将多余的精度信息通过一百万纳秒的数量是受整数除法。
    
    结果
    
    持续时间的总长度以毫秒为单位
    
    异常
    
    ArithmeticException如果数值溢出时
  - toNanos
```
public long toNanos()
```
    将这个时间的总长度来表示为一个 long。
    如果这个时间太大了long纳秒，然后抛出一个异常。
    
    结果
    
    纳秒级时间总长度
    
    异常
    
    ArithmeticException如果数值溢出时
  - compareTo
```
public int compareTo(Duration otherDuration)
```
    比较这个时间到指定的 Duration。
    比较是基于总长度的持续时间。这是“等于”一致，所定义的Comparable。
    
    Specified by:
    
    compareTo 接口 Comparable<Duration>
    
    参数
    
    otherDuration -相比其他时间，不空
    
    结果
    
    比较器的值，负的，如果少，积极的，如果更大
  - equals
```
public boolean equals(Object otherDuration)
```
    如果这个检查持续时间等于指定的 Duration。
    比较是基于总长度的持续时间。
    
    重写：
    
    equals 方法重写，继承类 Object
    
    参数
    
    otherDuration -其他时间、空返回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秒”--“pt20.345s“15分钟”（15×60秒）--“pt15m”“10小时”（10×3600秒）--“pt10h”“2天”（2×86400秒）--“pt48h”
```
    注意24小时倍数不输出天避免混乱与 Period。
    重写：
    
    toString 方法重写，继承类 Object
    
    结果
    
    这个时间ISO-8601表示，不为空

Submit a bug or feature
For further API reference and developer documentation, see Java SE Documentation. That documentation contains more detailed, developer-targeted descriptions, with conceptual overviews, definitions of terms, workarounds, and working code examples.
Copyright © 1993, 2014, Oracle and/or its affiliates. All rights reserved.

Class Duration

Field Summary

方法摘要

Methods inherited from class java.lang.Object

Field Detail

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

negated

abs

addTo

subtractFrom

toDays

toHours

toMinutes

toMillis

toNanos

compareTo

equals

hashCode

toString