betacode

Руководство Java Duration

Следуйте за нами на нашей фан-странице, чтобы получать уведомления каждый раз, когда появляются новые статьи. Facebook

1- Duration

Класс Duration представляет собой промежуток времени с точностью до наносекунды. Например: "2 дня 3 часа", "2 часа 3 минуты 15 секунд", "2 секунды 123 наносекунды",..

public final class Duration
        implements TemporalAmount, Comparable<Duration>, Serializable
  • ChronoPeriod
  • Period
  • TemporalAmount
Классы Duration и Period представляют собой определенное количество времени, но у них есть различия. Duration представляет собой точное количество времени, в то время как Period представляет собой предполагаемое количество времени.
  • Duration может быть преобразована в NANOS, MILLIS, SECONDS, MINITES, HOURS или DAYS. Эти единицы измерения являются точными, при этом 1 день считается 24 часами.
  • Period поддерживает единицы измерения DAYS, MONTHS, YEARS, они независимы друг от друга. Причина состоит в том, что эти единицы измерения являются оценочными, они не имеют фиксированной длины.
Например:
  Example
Duration 1 days 23 hours 15 seconds
Period 3 years 5 months 1 days
Значения  дня, часа, минуты, секунды, миллисекунды, наносекунды в Duration могут быть преобразованы друг в друга. Например, "13 часов 90 минут" равно "14 часам 30 минутам".
Даже несмотря на то, что Duration - это класс, основанный на количестве наносекунд. Но чтобы сравнить 2 объекта Duration, вы должны использовать метод equals(Object).

2- Factory methods

Статические заводские методы:

public static Duration ofDays(long days)  
public static Duration ofHours(long hours)  
public static Duration ofMinutes(long minutes)
public static Duration ofSeconds(long seconds)
public static Duration ofSeconds(long seconds, long nanoAdjustment)
public static Duration ofMillis(long millis)
public static Duration ofNanos(long nanos)
public static Duration of(long amount, TemporalUnit unit)
public static Duration from(TemporalAmount amount)
public static Duration parse(CharSequence text)  
public static Duration between(Temporal startInclusive, Temporal endExclusive)
Например: Создайте Duration из секунд и наносекунд:
Duration_ofSeconds_ex2.java

// ofSeconds(long seconds, long nanoAdjustment)
// 3 minutes 20 seconds 12345 nanoseconds.
Duration duration = Duration.ofSeconds(3*60 + 20, 12345); // 3M 20S 12345 Nanos.

System.out.println(duration); // PT3M20.000012345S
System.out.println("duration.toHoursPart(): " + duration.toHoursPart()); // 0
System.out.println("duration.toMinutesPart(): " + duration.toMinutesPart()); // 3
System.out.println("duration.toSecondsPart(): " + duration.toSecondsPart()); // 20
System.out.println("duration.toNanosPart(): " + duration.toNanosPart()); // 12345
Например: Создайте Duration, которая представляет собой временной интервал между 2 объектами Temporal. Примечание: Эти два  объекта Temporal должны поддерживать ChronoUnit.SECONDS, в противном случае будет выдано исключение. Для обеспечения максимальной точности необходимо поддерживать ChronoUnit.NANOS или ChronoField.NANO_OF_SECOND.
Duration_between_ex1.java

LocalDateTime localDateTime1 = LocalDateTime.of(2020, 5, 15, 13, 30, 45);
LocalDateTime localDateTime2 = LocalDate.of(2020, 5, 17).atStartOfDay();

Duration duration = Duration.between(localDateTime1, localDateTime2);

System.out.println(duration); // PT34H29M15S  (10 hours 29 minutes 15 seconds).
System.out.println("duration.toHoursPart(): " + duration.toHoursPart()); // 10
System.out.println("duration.toMinutesPart(): " + duration.toMinutesPart()); // 29
System.out.println("duration.toSecondsPart(): " + duration.toSecondsPart()); // 15

3- Other methods

Другие методы:

public boolean isZero()  
public boolean isNegative()  

// -----------------------------------------------------------------
// getX()
// -----------------------------------------------------------------

// Inherited from TemporalAmount interface
public long get(TemporalUnit unit)

// Inherited from TemporalAmount interface
public List<TemporalUnit> getUnits()

public long getSeconds()  
public int getNano()  

// -----------------------------------------------------------------
// withX()
// -----------------------------------------------------------------

public Duration withSeconds(long seconds)  
public Duration withNanos(int nanoOfSecond)

// -----------------------------------------------------------------
// plusX()
// -----------------------------------------------------------------
public Duration plus(Duration duration)  
public Duration plus(long amountToAdd, TemporalUnit unit)  

public Duration plusDays(long daysToAdd)  
public Duration plusHours(long hoursToAdd)  
public Duration plusMinutes(long minutesToAdd)  
public Duration plusSeconds(long secondsToAdd)  
public Duration plusMillis(long millisToAdd)  
public Duration plusNanos(long nanosToAdd)  

// -----------------------------------------------------------------
// minusX()
// -----------------------------------------------------------------
public Duration minus(Duration duration)  
public Duration minus(long amountToSubtract, TemporalUnit unit)

public Duration minusDays(long daysToSubtract)
public Duration minusHours(long hoursToSubtract)  
public Duration minusMinutes(long minutesToSubtract)  
public Duration minusSeconds(long secondsToSubtract)  
public Duration minusMillis(long millisToSubtract)
public Duration minusNanos(long nanosToSubtract)  

// -----------------------------------------------------------------
// toX()
// -----------------------------------------------------------------

public long toDays()  
public long toHours()  
public long toMinutes()  
public long toSeconds()  
public long toMillis()  
public long toNanos()  

// -----------------------------------------------------------------
// toXPart()
// -----------------------------------------------------------------

public long toDaysPart()  
public int toHoursPart()  
public int toMinutesPart()
public int toSecondsPart()  
public int toMillisPart()  
public int toNanosPart()  

// -----------------------------------------------------------------
// Other methods:
// -----------------------------------------------------------------

public Duration truncatedTo(TemporalUnit unit)
public Duration multipliedBy(long multiplicand)
public Duration dividedBy(long divisor)
public long dividedBy(Duration divisor)
public Duration negated()  
public Duration abs()  

// Inherited from TemporalAmount interface
public Temporal addTo(Temporal temporal)

// Inherited from TemporalAmount interface
public Temporal subtractFrom(Temporal temporal)  

4- toX() *

Метод toNanos() возвращает общее количество наносекунд в этой Duration.
Другие методы, такие как toMillis(), toSeconds(), toMinutes(), toHours(), toDays() также интерпретируются аналогично их названиям.

public long toNanos()  
public long toMillis()  
public long toSeconds()  
public long toMinutes()  
public long toHours()  
public long toDays() 
В частности, у нас есть:
  • toMinutes() равно целой части деления toSeconds() на 60.
  • toHours() равно целой части деления toSeconds() на 60*60.
  • toDays() равно целой части деления toSeconds() на 24*60*60.
(*) Если toNanos() > Long.MAX_VALUE или toMillis() > Long.MAX_VALUE, то будет выдано исключение ArithmeticException.
toX() Same as: Equals to Ranges
toNanos()      0-Long.MAX_VALUE
toMillis()      
toSeconds() getSeconds()  
toMinutes()   toSeconds() / 60
toHours()    toSeconds() / (60*60)
toDays()     toSeconds() / (24*60*60)
Например:
Duration_toX_ex1.java

// 10 days 10 hours 10 minutes 10 seconds.
long seconds = 10 * 24 * 60 * 60 + 10 * 60 * 60 + 10 * 60 + 10;

//
// 1 milliseconds = 10^6 nanoseconds
// 1 seconds = 10^9 nanoseconds
//
// (10 days 10 hours 10 minutes 10 seconds) + (10 milliseconds 10 nanoseconds).
long nanos = seconds * 1000000000L + 10 * 1000000L + 10L;

Duration duration = Duration.ofNanos(nanos);

System.out.println(duration); // PT250H10M10.01000001S

System.out.println("duration.toDays(): " + duration.toDays()); // 10
System.out.println("duration.toHours(): " + duration.toHours()); // 250
System.out.println("duration.toMinutes(): " + duration.toMinutes()); // 15010
System.out.println("duration.toSeconds(): " + duration.toSeconds()); // 900610
System.out.println("duration.toMillis(): " + duration.toMillis()); // 900610010
System.out.println("duration.toNanos(): " + duration.toNanos()); // 900610010000010

System.out.println("duration.getSeconds(): " + duration.getSeconds()); // 900610

5- toXPart() *

Метод toNanosPart() возвращает наносекундную часть этой Duration, которая не является общим количеством наносекунд в Duration.
Методы toMillisPart(), toMinutesPart(), toHoursPart() также интерпретируются аналогично их названиям.
Метод toDaysPart() возвращает тот же результат, что и toDays().

public int toNanosPart()  
public int toMillisPart()  
public int toSecondsPart()  
public int toMinutesPart()
public int toHoursPart()  
public long toDaysPart() 
toX() Same as: Equals to Range
toDaysPart()   toDays() toDays() 0-Long.MAX_VALUE
toHoursPart()     toHours() % 24 0-23
toMinutesPart()   toMinutes() % 60 0-59
toSecondsPart()     toSeconds() % 60 0-59
toMillisPart()     toMillis() % 10^3 0-10^3-1
toNanosPart()  getNano() toNanos() % 10^9 0-10^9-1
Например:
Duration_toXPart_ex1.java

// 10 days 10 hours 10 minutes 10 seconds.
long seconds = 10 * 24 * 60 * 60 + 10 * 60 * 60 + 10 * 60 + 10;

//
// 1 milliseconds = 10^6 nanoseconds
// 1 seconds = 10^9 nanoseconds
//
// (10 days 10 hours 10 minutes 10 seconds) + (10 milliseconds 10 nanoseconds).
long nanos = seconds * 1000000000L + 10 * 1000000L + 10;

Duration duration = Duration.ofNanos(nanos);

System.out.println(duration); // PT250H10M10.01000001S

System.out.println("duration.toDaysPart(): " + duration.toDaysPart()); // 10
System.out.println("duration.toHoursPart(): " + duration.toHoursPart()); // 10
System.out.println("duration.toMinutesPart: " + duration.toMinutesPart()); // 10
System.out.println("duration.toSecondsPart: " + duration.toSecondsPart()); // 10

System.out.println("duration.toMillisPart: " + duration.toMillisPart()); // 10
System.out.println("duration.toNanosPart: " + duration.toNanosPart()); // 10000010

System.out.println("duration.getNano(): " + duration.getNano()); // 10000010

6- isZero()

Возвращает значение true, если общее количество наносекунд в этой Duration равно 0, в противном случае возвращает значение false.

public boolean isZero() 
Например:
Duration_isZero_ex1.java

// Duration using parse() method
Duration duration1 = Duration.parse("P0DT0H0M");
System.out.println("duration1: " + duration1); // PT0S
System.out.println("duration1.isZero(): " + duration1.isZero()); // true

Duration duration2 = Duration.parse("P0DT0H20M");
System.out.println("\nduration2: " + duration2); // PT20M
System.out.println("duration2.isZero(): " + duration2.isZero()); // false

Duration duration3 =  duration2.minus(Duration.ofMinutes(20));
System.out.println("\nduration3: " + duration3); // PT0S
System.out.println("duration3.isZero(): " + duration3.isZero()); // true

Duration duration4 =  Duration.parse("P0DT1H-60M"); // 1 hour & -60 minutes
System.out.println("\nduration4: " + duration4); // PT0S
System.out.println("duration4.isZero(): " + duration4.isZero()); // true
Output:

duration1: PT0S
duration1.isZero(): true

duration2: PT20M
duration2.isZero(): false

duration3: PT0S
duration3.isZero(): true

duration4: PT0S
duration4.isZero(): true

7- isNegative()

Возвращает значение true, если общее количество наносекунд в этой Duration меньше 0, в противном случае возвращает значение false.

public boolean isNegative()  
Например:
Duration_isNegative_ex1.java

// 10 hours 10 minutes
Duration duration1 = Duration.ofMinutes(10 * 60 + 10);
// 20 hours 20 seconds
Duration duration2 = Duration.ofSeconds(20 * 60 * 60 + 20);

// duration1 - duration2
Duration duration = duration1.minus(duration2);
System.out.println("duration: " + duration); // PT-9H-50M-20S
System.out.println("duration.isNegative(): " + duration.isNegative()); // true
Output:

duration: PT-9H-50M-20S
duration.isNegative(): true

8- get(TemporalUnit)

Этот метод поддерживает только 2 единицы измерения,ChronoUnit.SECONDS и ChronoUnit.NANOS. Для других единиц измерения будет вызвано исключение.
  • get(ChronoUnit.SECONDS) возвращает общее количество секунд в этой Duration, что эквивалентно toSeconds().
  • get(ChronoUnit.NANOS) возвращает долю наносекунды в этой Duration, которая эквивалентна toNanosPart(), значение находится в диапазоне от 0 до 10^9-

// Inherited from TemporalAmount interface
public long get(TemporalUnit unit)
get(TemporalUnit) Same as Example
    2 minutes 12345 nanos
get(ChronoUnit.SECONDS) toSeconds() getSeconds() 2*60 seconds
get(ChronoUnit.NANOS) toNanosPart() getNano() 12345 nanos
Например:
Duration_get_unit_ex1.java

// 2 minutes 12345 nanoseconds.
Duration duration = Duration.ofSeconds(2 * 60, 12345);
System.out.println("duration: " + duration); // PT2M0.000012345S
System.out.println();  
 
System.out.println("SECONDS: " + duration.get(ChronoUnit.SECONDS)); // 120
System.out.println("NANOS: " + duration.get(ChronoUnit.NANOS)); // 12345

9- getUnits()

Возвращает единицы измерения, поддерживаемые этой Duration.

// Inherited from TemporalAmount interface
public List<TemporalUnit> getUnits()
Этот метод всегда возвращает List.of(ChronoUnit.SECONDS,ChronoUnit.NANOS).

10- getX() *

Метод getSeconds() возвращает общее количество секунд в этой Duration, что аналогично методу toSeconds().
Метод getNano() возвращает наносекундную часть этой Duration, которая совпадает с методом toNanosPart().

public long getSeconds()  
public int getNano()  
getX() Same as: Range Example
      2 minutes 12345 nanos
getSeconds() toSeconds() 0-Long.MAX_VALUE 120 seconds
getNano() toNanosPart() 0-10^9-1 12345 nano
Например:
Duration_getX_ex1.java

// 10 minutes 10 seconds 10 nanos.  (1 seconds = 10^9 nanos)
long nano = 10 * 60 * 1000000000L + 10 * 1000000000L + 10;

System.out.println("nano: " + nano); // 610000000010

Duration duration = Duration.ofNanos(nano);

System.out.println(duration); // PT10M10.00000001S

System.out.println("duration.getSeconds(): " + duration.getSeconds()); // 610
System.out.println("duration.getNano(): " + duration.getNano()); // 10

System.out.println("duration.toSeconds(): " + duration.toSeconds()); // 610
System.out.println("duration.toNanosPart(): " + duration.toNanosPart()); // 10
System.out.println("duration.toNanos(): " + duration.toNanos()); // 610000000010

11- withX(..) *


public Duration withSeconds(long seconds)  
public Duration withNanos(int nanoOfSecond)
Метод withSeconds(seconds) возвращает копию этой Duration, сохраняя наносекунды и заменяя общее количество секунд заданными секундами.
Duration_withSeconds_ex1.java

// 10 minutes 10 seconds 99 nanos
Duration duration = Duration.ofSeconds(10 * 60 + 10, 99);
System.out.println("duration: " + duration); // PT10M10.000000099S

// with 120 seconds (2 minutes)
Duration duration1 = duration.withSeconds(120);

System.out.println("duration1: " + duration1); // PT2M0.000000099S (2 minutes 99 nanos)
Метод withNanos(nanos) возвращает копию этой Duration, заменяет часть наносекунды и сохраняет остальные. Параметр nanos имеет значение от 0 до 10^9-1.
Duration_withNanos_ex1.java

// 10 minutes 10 seconds 99 nanos
Duration duration = Duration.ofSeconds(10 * 60 + 10, 99);
System.out.println("duration: " + duration); // PT10M10.000000099S

// with 111 nanos
Duration duration1 = duration.withNanos(111);
System.out.println("duration1: " + duration1); // PT10M10.000000111S (10 minutes 10 seconds 111 nanos)

12- plus(Duration)

Добавьте эту Duration с указанной Duration, чтобы создать новую Duration, возвращаемый результат нормализуется.

public Duration plus(Duration duration)  
Например:
Duration_plus_duration_ex1.java

// 20 hours 20 minutes 20 seconds
Duration duration1 = Duration.ofSeconds(20 * 60 * 60 + 20 * 60 + 20);
System.out.println("duration1: " + duration1); // PT20H20M20S

// 50 minutes 10 seconds
Duration duration2 = Duration.ofSeconds(50 * 60 + 10);
System.out.println("duration1: " + duration2); // PT50M10S

Duration duration3 = duration1.plus(duration2);
System.out.println("duration3: " + duration3); // PT21H10M30S (21 Hours 10 minutes 30 seconds) 
Output:

duration1: PT20H20M20S
duration1: PT50M10S
duration3: PT21H10M30S

13- plus(long, TemporalUnit)

Возвращает копию этой Duration с количеством времени, добавленным в данной единице измерения.

public Duration plus(long amountToAdd, TemporalUnit unit)  
Примечание: Этот метод поддерживает только TemporalUnit с точной продолжительностью. Например, ChronoUnit.DAYS эквивалентно 24 часам. ChronoUnit.MONTHS считаются приблизительными (estimate), поскольку их длина не фиксирована. Короче говоря, этот метод поддерживает temporalUnit, если функция temporalUnit.isDurationEstimated() возвращает значение false.
Поддерживаются следующие стандартные единицы измерения:
  • ChronoUnit.NANOS
  • ChronoUnit.MICROS
  • ChronoUnit.MILLIS
  • ChronoUnit.SECONDS
  • ChronoUnit.MINUTES
  • ChronoUnit.HOURS
  • ChronoUnit.HALF_DAYS
  • ChronoUnit.DAYS
Например:
Duration_plus_unit_ex1.java

// 10 hours 10 minutes 10 seconds
Duration duration1 = Duration.ofSeconds(10 * 60 * 60 + 10 * 60 + 10);
System.out.println("duration1: " + duration1); // PT10H10M10S

// plus 1 DAY (24 Hours)
Duration duration2 = duration1.plus(1, ChronoUnit.DAYS);
System.out.println("duration2: " + duration2); // PT34H10M10S (34 hours 12 minutes 40 seconds)

// plus 150 Seconds  (2 minutes 30 seconds)
Duration duration3 = duration1.plus(150, ChronoUnit.SECONDS);
System.out.println("duration3: " + duration3); // PT10H12M40S (10 hours 12 minutes 40 seconds)

14- plusX(..) *

Метод plusNanos(nanosToAdd) возвращает копию этой Duration с добавлением указанного количества наносекунд.
Другие методы, такие как plusMillis(millisToAdd), plusSeconds(secondsToAdd), plusMinutes(long minutesToAdd), plusHours(hoursToAdd), plusDays(daysToAdd), также интерпретируются аналогично их названиям.

public Duration plusNanos(long nanosToAdd)  
public Duration plusMillis(long millisToAdd)  
public Duration plusSeconds(long secondsToAdd)  
public Duration plusMinutes(long minutesToAdd)  
public Duration plusHours(long hoursToAdd)  
public Duration plusDays(long daysToAdd)
Например:
Duration_plusX_ex1.java

// 10 hours 10 minutes 10 seconds
Duration duration1 = Duration.ofSeconds(10 * 60 * 60 + 10 * 60 + 10);
System.out.println("duration1: " + duration1); // PT10H10M10S

// plus 150 seconds. (2 minutes 30 seconds)
Duration duration2 = duration1.plusSeconds(150);
System.out.println("duration2: " + duration2); // PT10H12M40S (10 hours 12 minutes 40 seconds)

// plus -30 minutes.
Duration duration3 = duration1.plusMinutes(-30);
System.out.println("duration3: " + duration3); // PT9H40M10S (9 hours 10 minutes 10 seconds)

15- minus(Duration)

Вычитает указанную Duration из этой Duration и возвращает новую Duration. Возвращенный результат нормализуется.

public Duration minus(Duration duration)  
Например:
Duration_minus_duration_ex1.java

// 20 hours 20 minutes 20 seconds
Duration duration1 = Duration.ofSeconds(20 * 60 * 60 + 20 * 60 + 20);
System.out.println("duration1: " + duration1); // PT20H20M20S

// 50 minutes 10 seconds
Duration duration2 = Duration.ofSeconds(50 * 60 + 10);
System.out.println("duration2: " + duration2); // PT50M10S

// duration1 - duration2
Duration duration3 = duration1.minus(duration2);
System.out.println("duration3: " + duration3); // PT19H30M10S (19 Hours 30 minutes 10 seconds) 
Output:

duration1: PT20H20M20S
duration2: PT50M10S
duration3: PT19H30M10S

16- minus(long, TemporalUnit)

Возвращает копию этой Duration с указанным количеством времени, вычитаемым в данной единице измерения.

public Duration minus(long amountToSubtract, TemporalUnit unit)
Примечание: Этот метод поддерживает только TemporalUnit с точной продолжительностью. Например, ChronoUnit.DAYS эквивалентно 24 часам. ChronoUnit.MONTHS считаются приблизительными (estimate), поскольку их продолжительность не является фиксированной. Короче говоря, этот метод поддерживает temporalUnit, если функция temporalUnit.isDurationEstimated() возвращает значение false.
Поддерживаются следующие стандартные единицы измерения:
  • ChronoUnit.NANOS
  • ChronoUnit.MICROS
  • ChronoUnit.MILLIS
  • ChronoUnit.SECONDS
  • ChronoUnit.MINUTES
  • ChronoUnit.HOURS
  • ChronoUnit.HALF_DAYS
  • ChronoUnit.DAYS
Например:
Duration_minus_unit_ex1.java

// 25 hours 10 minutes 10 seconds
Duration duration1 = Duration.ofSeconds(25 * 60 * 60 + 10 * 60 + 10);
System.out.println("duration1: " + duration1); // PT25H10M10S

// minus 1 DAY (24 Hours)
Duration duration2 = duration1.minus(1, ChronoUnit.DAYS);
System.out.println("duration2: " + duration2); // PT1H10M10S (1 hours 10 minutes 10 seconds)

// minus 150 Seconds  (2 minutes 30 seconds)
Duration duration3 = duration1.minus(150, ChronoUnit.SECONDS);
System.out.println("duration3: " + duration3); // PT25H7M40S (25 hours 7 minutes 40 seconds)

17- minusX(..) *

Метод minusNanos(nanosToSubtract) возвращает копию этой Duration с вычитанием указанного количества наносекунд.
Другие методы, такие как minusMillis(millisToSubtract), minusSeconds(secondsToSubtract), minusMinutes(long minutesToSubtract), minusHours(hoursToSubtract), minusDays(daysToSubtract), также интерпретируются аналогично их названиям.

public Duration minusNanos(long nanosToSubtract)  
public Duration minusMillis(long millisToSubtract)
public Duration minusSeconds(long secondsToSubtract)  
public Duration minusMinutes(long minutesToSubtract)  
public Duration minusHours(long hoursToSubtract)  
public Duration minusDays(long daysToSubtract)
Например:
Duration_minusX_ex1.java

// 10 hours 10 minutes 10 seconds
Duration duration1 = Duration.ofSeconds(10 * 60 * 60 + 10 * 60 + 10);
System.out.println("duration1: " + duration1); // PT10H10M10S

// minus 30 seconds.
Duration duration2 = duration1.minusSeconds(30);
System.out.println("duration2: " + duration2); // PT10H7M40S (10 hours 9 minutes 40 seconds)

18- truncatedTo(TemporalUnit)

Возвращает копию этого объекта Duration, усеченную (truncated) до указанной единицы измерения.

public Duration truncatedTo(TemporalUnit unit)
Этот метод поддерживает ChronoUnit.DAYS и все единицы измерения, основанные на времени (time-based), это означает, что функция temporalUnit.isTimeBased() является true. Другие единицы измерения выдадут исключение.
Например:
Duration_truncatedTo_ex1.java

// 10 hours 10 minutes 10 seconds
Duration duration1 = Duration.ofSeconds(10 * 60 * 60 + 10 * 60 + 10);
System.out.println("duration1: " + duration1); // PT10H10M10S

// Truncated to ChronoUnit.MINUTES
Duration duration2 = duration1.truncatedTo(ChronoUnit.MINUTES);
System.out.println("duration2: " + duration2); // PT10H10M (10 hours 10 minutes)

19- negated()

Возвращает отрицательную копию этой Duration. То есть, добавление возвращаемой Duration, и эта Duration равна 0.

public Duration negated()  
Например:
Duration_negated_ex1.java

// 20 hours 20 minutes 20 seconds
Duration duration1 = Duration.ofSeconds(20 * 60 * 60 + 20 * 60 + 20);
System.out.println("duration1: " + duration1); // PT20H20M20S

// duration2 = 0 - duration1
Duration duration2 = duration1.negated();
System.out.println("duration2: " + duration2); // PT-20H-20M-20S 

20- abs()

Возвращает копию абсолютного значения этой Duration, это означает, что возвращенная длина Duration является положительным значением.

public Duration abs()  
Например:
Duration_abs_ex1.java

// -20 hours, 20 minutes, -20 seconds
Duration duration1 = Duration.parse("PT-20H20M-20S");
System.out.println("duration1: " + duration1); // PT-19H-40M-20S (-19H, -40M, -20S)

// duration2 = duration1 < 0 ? -duration1 : duration1;
Duration duration2 = duration1.abs();
System.out.println("duration2: " + duration2); // PT19H40M20S (19H 40M 20S)

21- addTo(Temporal)

Добавляет эту Duration к указанному объекту Temporal и возвращает копию этого объекта Temporal.

// Inherited from TemporalAmount interface
public Temporal addTo(Temporal temporal)
Этот метод эквивалентен методу Temporal.plus(TemporalAmount).

Temporal copiedTemporal = temporal.plus(duration);

Temporal copiedTemporal = duration.addTo(temporal);
Например:
Duration_addTo_ex1.java

// Create Temporal object.
LocalDateTime localDateTime = LocalDateTime.of(1985, 12, 31, 23, 30, 0);
System.out.println("localDateTime: " + localDateTime); // 1985-12-31T23:30

// 1 Hour
Duration duration = Duration.ofHours(1);

LocalDateTime newLocalDateTime = (LocalDateTime) duration.addTo(localDateTime);
System.out.println("newLocalDateTime: " + newLocalDateTime); // 1986-01-01T00:30
1 января 1986 года правительство Непала объявило свой часовой пояс +5h45 GMT. Это означает, что они на 15 минут быстрее, чем в соседней Индии. Этот шаг призван изменить ситуацию с соседом-гигантом и продемонстрировать национальную гордость непальского народа.
Таким образом, 1 января 1986 года в 0 часов 0 минут 0 секунд в Индии эквивалентно 0 часам 15 минутам 0 секундам в Непале. Непальцы перевели свои часы на 15 минут быстрее, чем индийцы.
Мы посмотрим, что произойдет в 23:30 31 декабря 1985 года в Непале, а затем 1 час спустя:
Duration_addTo_ex2.java

ZoneId nepalZoneId = ZoneId.of("Asia/Kathmandu");

// Create Temporal object.
ZonedDateTime zonedDateTime = ZonedDateTime.of(1985, 12, 31, 23, 30, 0, 0, nepalZoneId);
System.out.println("zonedDateTime: " + zonedDateTime); // 1985-12-31T23:30+05:30[Asia/Kathmandu]

// 1 Hour
Duration duration = Duration.ofHours(1);

ZonedDateTime newZonedDateTime = (ZonedDateTime) duration.addTo(zonedDateTime);
System.out.println("newZonedDateTime: " + newZonedDateTime); // 1986-01-01T00:45+05:45[Asia/Kathmandu]
Output:

zonedDateTime: 1985-12-31T23:30+05:30[Asia/Kathmandu]
newZonedDateTime: 1986-01-01T00:45+05:45[Asia/Kathmandu]

22- subtractFrom(Temporal)

Вычитает эту Duration из указанного объекта Temporal и возвращает копию этого объекта Temporal.

// Inherited from TemporalAmount interface
public Temporal subtractFrom(Temporal temporal)  
Этот метод эквивалентен методу Temporal.minus(TemporalAmount).

Temporal copiedTemporal = temporal.minus(duration);

Temporal copiedTemporal = duration.subtractFrom(temporal);
Например:
Duration_subtractFrom_ex1.java

// Create Temporal object.
LocalDateTime localDateTime = LocalDateTime.of(2000, 1, 1, 0, 30, 0);
System.out.println("localDateTime: " + localDateTime); // 2000-01-01T00:30

// 1 Hour
Duration duration = Duration.ofHours(1);

LocalDateTime newLocalDateTime = (LocalDateTime) duration.subtractFrom(localDateTime);
System.out.println("newLocalDateTime: " + newLocalDateTime); // 1999-12-31T23:30

23- multipliedBy(long)

Умножает эту Duration на указанное значение и возвращает новую Duration. Возвращенный результат нормализуется.

public Duration multipliedBy(long multiplicand)
Например:
Duration_multipliedBy_ex1.java

// 30 minutes 25 seconds
Duration duration1 = Duration.ofSeconds(30 * 60 + 25);
System.out.println("duration1: " + duration1); // PT30M25S

// duration2 = duration1 * 2
Duration duration2 = duration1.multipliedBy(2);
System.out.println("duration2: " + duration2); // PT1H50S (1 Hour 50 seconds)

24- dividedBy(long)

Эта Duration делится на указанное значение и возвращает новую Duration. Возвращенный результат нормализуется.

public Duration dividedBy(long divisor)
Например:
Duration_dividedBy_ex1.java

// 1 hour 30 minutes 25 seconds
Duration duration1 = Duration.ofSeconds(1 * 60 * 60 + 30 * 60 + 25);
System.out.println("duration1: " + duration1); // PT1H30M25S

// duration2 = duration1 / 2
Duration duration2 = duration1.dividedBy(2);
System.out.println("duration2: " + duration2); // PT45M12.5S (45 minutes 12.5 seconds)

25- dividedBy(Duration)

Эта Duration делится на другую Duration и возвращает целое число.

public long dividedBy(Duration divisor)
Например:
Duration_dividedBy_ex2.java

// 1 hour 30 minutes 25 seconds
Duration duration1 = Duration.ofSeconds(1 * 60 * 60 + 30 * 60 + 25);
System.out.println("duration1: " + duration1); // PT1H30M25S
System.out.println("duration1.toNanos(): " + duration1.toNanos()); // 5425000000000

// 1 minute 30 seconds
Duration duration2 = Duration.ofSeconds(1 * 60 + 30);
System.out.println("duration2: " + duration2); // PT1M30S
System.out.println("duration2.toNanos(): " + duration2.toNanos()); // 90000000000

// duration1 / duration2
long result1 = duration1.dividedBy(duration2);
double result2 = (double) duration1.toNanos() / duration2.toNanos();
System.out.println("result1: " + result1); // 60
System.out.println("result2: " + result2); // 60.27777777777778
Maybe you are interested

Это онлайн курс вне вебсайта o7planning, который мы представляем, он включает бесплатные курсы или курсы со скидкой.