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到999,999,999之间。该模型具有定向持续时间，意味着持续时间可能为负。

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

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

实现要求：

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

从以下版本开始：

1.8

另请参见：

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` 。
`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`多个标准时数的Duration。
`static Duration`	`ofMillis(long millis)` 获得代表一个 `Duration`数的Duration。
`static Duration`	`ofMinutes(long minutes)` 获得 `Duration`多个标准分钟的Duration。
`static Duration`	`ofNanos(long nanos)` 获得 `Duration`数纳秒的Duration。
`static Duration`	`ofSeconds(long seconds)` 获得代表 `Duration` Duration。
`static Duration`	`ofSeconds(long seconds, long nanoAdjustment)` 获得一个 `Duration`代表秒数和一个纳秒的调整。
`static Duration`	`parse(CharSequence text)` 从一个文本字符串获得一个 `Duration` ，如 `PnDTnHnMn.nS` 。
`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

- 字段详细信息
  - 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多个标准时数的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 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 - millis数，正数或负数
    
    结果
    
    一个 Duration ，不为null
  - ofNanos
```
public static Duration ofNanos(long nanos)
```
    获得Duration数纳秒的Duration。
    从指定的纳秒提取秒和纳秒。
    
    参数
    
    nanos - 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"
    "P-6H3M"    -- parses as "-6 hours and +3 minutes"
    "-P6H3M"    -- parses as "-6 hours and -3 minutes"
    "-P-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
    
    结果
    
    单位的长期价值
    
    异常
    
    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基于此持续时间，指定的持续时间加上，不为空
    
    异常
    
    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 - 要添加的 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基于此持续时间加上指定的纳秒，不为null
    
    异常
    
    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基于此持续时间减去指定的小时，不为null
    
    异常
    
    ArithmeticException - 如果发生数字溢出
  - minusMinutes
```
public Duration minusMinutes(long minutesToSubtract)
```
    以指定的持续时间返回此持续时间的副本，以分钟为单位。
    小时数乘以60，以获得要减去的秒数。
    
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    minutesToSubtract - 减去正数或负数的 minutesToSubtract
    
    结果
    
    一个 Duration基于此持续时间减去指定的分钟，不为空
    
    异常
    
    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基于此持续时间减去指定的纳秒，不为空
    
    异常
    
    ArithmeticException - 如果发生数字溢出
  - multipliedBy
```
public Duration multipliedBy(long multiplicand)
```
    返回此持续时间的副本乘以标量。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    multiplicand - 将持续时间乘以正或负的值
    
    结果
    
    一个 Duration基于此持续时间乘以指定的标量，不为null
    
    异常
    
    ArithmeticException - 如果发生数字溢出
  - dividedBy
```
public Duration dividedBy(long divisor)
```
    返回此持续时间的副本除以指定的值。
    此实例是不可变的，不受此方法调用的影响。
    
    参数
    
    divisor - 将持续时间除以正或负的值不为零的值
    
    结果
    
    一个 Duration基于该持续时间除以指定的除数，不为null
    
    异常
    
    ArithmeticException - 如果除数为零或数字溢出发生
  - 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来返回持续时间内的总分钟数。
    
    此实例是不可变的，不受此方法调用的影响。
    
    结果
    
    持续时间内的分钟数可能为负数
  - toMillis
```
public long toMillis()
```
    将此持续时间转换为总长度（以毫秒为单位）。
    如果此持续时间太大，无法适应long毫秒，则会抛出异常。
    
    如果此持续时间大于毫秒精度，则转换将丢弃任何超量精度信息，就好像以毫秒为单位的整数除以一百万。
    
    结果
    
    持续时间的总长度（以毫秒为单位）
    
    异常
    
    ArithmeticException - 如果发生数字溢出
  - toNanos
```
public long toNanos()
```
    将此持续时间转换为总长度，单位为纳秒，表示为long 。
    如果这个持续时间太大而不能适应long纳秒，则抛出异常。
    
    结果
    
    持续时间的总长度以纳秒为单位
    
    异常
    
    ArithmeticException - 如果发生数字溢出
  - compareTo
```
public int compareTo(Duration otherDuration)
```
    将此持续时间与指定的Duration进行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

negated

abs

addTo

subtractFrom

toDays

toHours

toMinutes

toMillis

toNanos

compareTo

equals

hashCode

toString