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 以了解有关秒和时标含义的讨论。

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

实现要求：

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

自从：

1.8

参见：

字段摘要

字段

修饰符和类型

Field

描述

static final 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)

返回指定 Duration 在此 Duration 内出现的整数次。

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)

获得一个 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(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)
  
  获得一个 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 到 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);
  此方法仅接受部分单位。该单位必须有一个确切的持续时间或 ChronoUnit.DAYS 被视为 24 小时。其他单位抛出异常。
  参数：
  
  amount - 持续时间的量，以单位衡量，正数或负数
  
  unit - 测量持续时间的单位，必须有一个准确的持续时间，不为空
  
  返回：
  
  一个 Duration ，不为空
  
  抛出：
  
  DateTimeException - 如果周期单元有估计持续时间
  
  ArithmeticException - 如果发生数字溢出
- from
  
  public static Duration from(TemporalAmount amount)
  
  从时间量中获取 Duration 的实例。
  这将根据指定的数量获得持续时间。 TemporalAmount 表示时间量，它可以是基于日期或基于时间的，该工厂将其提取到持续时间。
  
  转换围绕金额的单位集循环，并使用单位的 duration 计算总计 Duration。这种方法只接受一部分单位。该单位必须有一个确切的持续时间或 ChronoUnit.DAYS 被视为 24 小时。如果找到任何其他单元，则会抛出异常。
  
  参数：
  
  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。小数点可以是点或逗号。小数部分可能有 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 - 要解析的文本，不为空
  
  返回：
  
  解析的持续时间，不为空
  
  抛出：
  
  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 表示时间线上两点之间的定向距离，因此可以为正、零或负。此方法检查长度是否大于零。
  
  返回：
  
  如果此持续时间的总长度大于零，则为真
  
  自从：
  
  18
- isZero
  
  public boolean isZero()
  
  检查此持续时间是否为零长度。
  Duration 表示时间线上两点之间的定向距离，因此可以为正、零或负。此方法检查长度是否为零。
  
  返回：
  
  如果此持续时间的总长度等于零，则为真
- isNegative
  
  public boolean isNegative()
  
  检查此持续时间是否为负数，不包括零。
  Duration 表示时间线上两点之间的定向距离，因此可以为正、零或负。此方法检查长度是否小于零。
  
  返回：
  
  如果此持续时间的总长度小于零，则为真
- 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 基于此持续时间并添加了指定的持续时间，不为空
  
  抛出：
  
  ArithmeticException - 如果发生数字溢出
- plus
  
  public Duration plus(long amountToAdd, TemporalUnit unit)
  
  返回此持续时间的副本，并添加了指定的持续时间。
  持续时间量以指定单位衡量。这种方法只接受一部分单位。该单位必须有一个确切的持续时间或 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)
  
  返回此持续时间的副本，并减去指定的持续时间。
  持续时间量以指定单位衡量。这种方法只接受一部分单位。该单位必须有一个确切的持续时间或 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 - 如果除数为零或发生数字溢出
- dividedBy
  
  public long dividedBy(Duration divisor)
  
  返回指定 Duration 在此 Duration 内出现的整数次。
  此实例是不可变的，不受此方法调用的影响。
  
  参数：
  
  divisor - 持续时间除以的值，正数或负数，不为空
  
  返回：
  
  整数次数，向零舍入，在此持续时间内发生指定的Duration，可能为负数
  
  抛出：
  
  ArithmeticException - 如果除数为零，或者发生数字溢出
  
  自从：
  
  9
- negated
  
  public Duration negated()
  
  返回此持续时间的副本，长度取反。
  此方法交换此持续时间的总长度的符号。例如，PT1.3S 将返回为 PT-1.3S。
  
  此实例是不可变的，不受此方法调用的影响。
  
  返回：
  
  a 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);
  
  计算将添加秒，然后是纳秒。只会添加非零金额。
  
  此实例是不可变的，不受此方法调用的影响。
  指定者：
  
  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);
  
  计算将减去秒，然后减去纳秒。只会添加非零金额。
  
  此实例是不可变的，不受此方法调用的影响。
  指定者：
  
  subtractFrom 在接口 TemporalAmount 中
  
  参数：
  
  temporal - 要调整的时间对象，不为空
  
  返回：
  
  进行了调整的同一类型的对象，不为空
  
  抛出：
  
  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 单位截断将向下舍入到零到最接近的分钟，将秒和纳秒设置为零。
  
  该单位必须有一个 duration，它可以划分为一个标准日的长度，没有余数。这包括所有 ChronoUnit 上的基于时间的单位和 DAYS 。其他 ChronoUnits 抛出异常。
  
  此实例是不可变的，不受此方法调用的影响。
  
  参数：
  
  unit - 要截断的单位，不为空
  
  返回：
  
  a Duration 基于此持续时间并截断时间，不为空
  
  抛出：
  
  DateTimeException - 如果单位对于截断无效
  
  UnsupportedTemporalTypeException - 如果不支持该单元
  
  自从：
  
  9
- compareTo
  
  public int compareTo(Duration otherDuration)
  
  将此持续时间与指定的 Duration 进行比较。
  比较基于持续时间的总长度。正如 Comparable 所定义的那样，它“与等于一致”。
  
  指定者：
  
  compareTo 在接口 Comparable<Duration> 中
  
  参数：
  
  otherDuration - 要比较的其他持续时间，不为空
  
  返回：
  
  比较值，小于则为负，大于则为正
- equals
  
  public boolean equals(Object other)
  
  检查此持续时间是否等于指定的 Duration 。
  比较基于持续时间的总长度。
  重写：
  
  equals 在类 Object 中
  
  参数：
  
  other - 其他持续时间，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 表示，不为空

类 Duration

字段摘要

方法总结

在类 java.lang.Object 中声明的方法

字段详细信息

ZERO

方法详情

ofDays

ofHours

ofMinutes

ofSeconds

ofSeconds

ofMillis

ofNanos

of

from

parse

between

get

getUnits

isPositive

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