codestory

Die Anleitung zu Java Duration

View more Tutorials:

Folge uns auf unserer fanpage, um jedes Mal benachrichtigt zu werden, wenn es neue Artikel gibt. Facebook

1- Duration

Die Klasse Duration repräsentiert eine Zeitspanne mit einer Genauigkeit von Nanosekunden. Zum Beispiel: "2 Tage 3 Stunden", "2 Stunden 3 Minuten 15 Sekunden", "2 Sekunden 123 Nanosekunden",...

public final class Duration
        implements TemporalAmount, Comparable<Duration>, Serializable
  • ChronoPeriod
  • Period
  • TemporalAmount
Die Klassen Duration und Period repräsentieren beide eine Zeitspanne, weisen jedoch Unterschiede auf. Duration stellt eine genaue Zeitdauer dar, während Period eine geschätzte Zeitdauer darstellt.
  • Duration kann in NANOS, MILLIS, SECONDS, MINITES, HOURS oder DAYS umgewandelt werden. Diese Einheiten sind präzise, ​​wobei 1 Tag als 24 Stunden gilt
  • Period unterstützt DAYS, MONTHS, YEARS Einheiten, sie sind unabhängig voneinander. Der Grund dafür ist, dass es sich bei diesen Einheiten um Schätzungen handelt, sie haben keine feste Länge
Zum Beispiel:
  Example
Duration 1 days 23 hours 15 seconds
Period 3 years 5 months 1 days
Die Werte für Tag, Stunde, Minute, Sekunde, Millisekunde, Nanosekunde in Duration können ineinander umgerechnet werden. Beispiel: "13 Stunden und 90 Minuten" entspricht "14 Stunden und 30 Minuten".
Obwohl Duration eine Klasse ist, die auf der Anzahl von Nanosekunden basiert. Um jedoch 2 Objekte Duration zu vergleichen, sollten Sie die Methode equals(Object) verwenden.

2- Factory methods

Statische Fabrikmethoden:

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)
Beispiel: Erstellen Sie eine Duration aus Sekunden und Nanosekunden:
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
Beispiel: Erstellen Sie eine Duration , die das Zeitintervall zwischen 2 Objekten is Temporal ist. Hinweis: Diese beiden Objekte Temporal müssen ChronoUnit.SECONDS unterstützen, andernfalls wird eine Ausnahme ausgelöst. Für höchste Genauigkeit muss ChronoUnit.NANOS oder ChronoField.NANO_OF_SECOND unterstützt werden.
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

Die anderen Methode:

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() *

Die Methode toNanos() gibt die gesamten Nanosekunden in dieser Duration zurück.
Als Namen werden auch andere Methoden wie toMillis(), toSeconds(), toMinutes(), toHours(), toDays() verstanden.

public long toNanos()  
public long toMillis()  
public long toSeconds()  
public long toMinutes()  
public long toHours()  
public long toDays() 
Konkret haben wir:
  • toMinutes() entspricht dem ganzzahligen Teil von toSeconds() Division durch 60.
  • toHours() entspricht dem ganzzahligen Teil der toSeconds() Division durch 60*60.
  • toDays() entspricht dem ganzzahligen Teil der toSeconds() Division durch 24*60*60.
(*) Wenn toNanos() > Long.MAX_VALUE oder toNanos() > Long.MAX_VALUE ist, wird ArithmeticException geworfen.
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)
Zum Beispiel:
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() *

Die Methode toNanosPart() gibt den Nanosekundenteil dieser Duration zurück, der nicht die gesamten Nanosekunden in der Duration ist.
Als Namen werden auch die Methoden toMillisPart(), toMinutesPart(), toHoursPart() verstanden.
Die Methode toDaysPart() gibt das gleiche Ergebnis wie toDays() zurück.

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
Zum Beispiel:
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()

Geben Sie true zurück, wenn die Gesamtzahl der Nanosekunden in dieser Duration 0 ist, andernfalls geben Sie false zurück.

public boolean isZero() 
Zum Beispiel:
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()

Geben Sie true zurück, wenn die Gesamtzahl der Nanosekunden in dieser Duration kleiner als 0 ist, andernfalls geben Sie false zurück.

public boolean isNegative()  
Zum Beispiel:
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)

Diese Methode unterstützt nur 2 Einheiten, ChronoUnit.SECONDS und ChronoUnit.NANOS. Andere Einheiten lösen eine Ausnahme aus.
  • get(ChronoUnit.SECONDS) gibt die Gesamtsekunden in dieser Duration zurück, was toSeconds() entspricht.
  • get(ChronoUnit.NANOS) gibt den Nanosekundenteil in dieser Duration zurück, was toNanosPart() entspricht, der Wert liegt im Bereich von 0 bis 10^9-1.

// 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
Zum Beispiel:
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()

Geben Sie die Einheiten zurück, die von dieser Duration unterstützt werden

// Inherited from TemporalAmount interface
public List<TemporalUnit> getUnits()
Diese Methode gibt immer List.of(ChronoUnit.SECONDS,ChronoUnit.NANOS) zurück.

10- getX() *

Die Methode getSeconds() gibt die Gesamtsekunden in dieser Duration zurück, ähnlich der Methode toSeconds().
Die Methode getNano() gibt den Nanosekundenteil dieser Duration zurück, der mit der Methode toNanosPart() identisch ist.

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
Zum Beispiel:
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)
Die Methode withSeconds(seconds) gibt eine Kopie dieser Duration zurück, behält die Nanosekunden bei und ersetzt die Gesamtsekunden durch die angegebenen Sekunden.
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)
Die Methode withNanos(nanos) gibt eine Kopie dieser Duration zurück, ersetzt den Nanosekundenteil und behält die anderen. Der Nanos-Parameter hat einen Wert von 0 bis 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)

Fügen Sie diese Duration mit einer angegebenen Duration hinzu, um eine neue Duration zu erstellen. Das zurückgegebene Ergebnis wird normalisiert.

public Duration plus(Duration duration)  
Zum Beispiel:
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)

Geben Sie eine Kopie dieser Duration mit einer hinzugefügten Zeit in der angegebenen Einheit zurück.

public Duration plus(long amountToAdd, TemporalUnit unit)  
Hinweis: Diese Methode unterstützt nur TemporalUnit mit genauer Dauer. ChronoUnit.DAYS entspricht beispielsweise 24 Stunden. ChronoUnit.MONTHS gilt als Schätzung, da die Länge nicht festgelegt ist. Kurz gesagt, eine temporalUnit wird von dieser Methode unterstützt, wenn temporalUnit.isDurationEstimated() false zurückgibt.
Die folgenden Standardeinheiten werden unterstützt:
  • ChronoUnit.NANOS
  • ChronoUnit.MICROS
  • ChronoUnit.MILLIS
  • ChronoUnit.SECONDS
  • ChronoUnit.MINUTES
  • ChronoUnit.HOURS
  • ChronoUnit.HALF_DAYS
  • ChronoUnit.DAYS
Zum Beispiel:
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(..) *

Die plusNanos(nanosToAdd)-Methode gibt eine Kopie dieser Duration mit der angegebenen Anzahl an hinzugefügten Nanosekunden zurück.
Andere Methoden wie plusMillis(millisToAdd), plusSeconds(secondsToAdd), plusMinutes(long minutesToAdd), plusHours(hoursToAdd), plusDays(daysToAdd) werden genauso verstanden wie ihre Namen.

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)
Zum Beispiel:
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)

Subtrahieren Sie eine angegebene Duration von dieser Duration und geben Sie eine neue Duration zurück. Das zurückgegebene Ergebnis wird normalisiert.

public Duration minus(Duration duration)  
Zum Beispiel:
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)

Geben Sie eine Kopie dieser Duration mit der angegebenen Zeit subtrahiert in der angegebenen Einheit zurück.

public Duration minus(long amountToSubtract, TemporalUnit unit)
Hinweis: Diese Methode unterstützt nur TemporalUnit mit genauer Dauer. ChronoUnit.DAYS entspricht beispielsweise 24 Stunden. ChronoUnit.MONTHS gilt als Schätzung, da die Länge nicht festgelegt ist. Kurz gesagt, eine temporalUnit wird von dieser Methode unterstützt, wenn temporalUnit.isDurationEstimated() false zurückgibt.
Die folgenden Standardeinheiten werden unterstützt:
  • ChronoUnit.NANOS
  • ChronoUnit.MICROS
  • ChronoUnit.MILLIS
  • ChronoUnit.SECONDS
  • ChronoUnit.MINUTES
  • ChronoUnit.HOURS
  • ChronoUnit.HALF_DAYS
  • ChronoUnit.DAYS
Zum Beispiel:
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(..) *

Die Methode minusNanos(nanosToSubtract) gibt eine Kopie dieser Duration mit der angegebenen Anzahl von Nanosekunden subtrahiert zurück.
Andere Methoden wie minusMillis(millisToSubtract), minusSeconds(secondsToSubtract), minusMinutes(long minutesToSubtract), minusHours(hoursToSubtract), minusDays(daysToSubtract) werden ebenso wie ihre Namen verstanden.

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)
Zum Beispiel:
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)

Gibt eine Kopie dieses Objekt Duration zurück, die auf die angegebene Einheit gekürzt wurde.

public Duration truncatedTo(TemporalUnit unit)
Diese Methode unterstützt ChronoUnit.DAYS und alle zeitbasierten Einheiten, was bedeutet, dass temporalUnit.isTimeBased() true ist. Andere Einheiten lösen eine Ausnahme aus.
Zum Beispiel:
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()

Senden Sie eine negative Kopie dieser Duration zurück. Das heißt, die Addition der zurückgegebenen Duration und dieser Duration entspricht 0.

public Duration negated()  
Zum Beispiel
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()

Geben Sie eine Kopie des absoluten Werts dieser Duration zurück. Dies bedeutet, dass die Länge von  zurückgegebener​​​​​​​ Duration ein positiver Wert ist

public Duration abs()  
Zum Beispiel:
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)

Fügen Sie diese Duration einem angegebenen Objekt Temporal hinzu und geben Sie eine Kopie dieses Objekts Temporal zurück.

// Inherited from TemporalAmount interface
public Temporal addTo(Temporal temporal)
Diese Methode entspricht der Methode Temporal.plus(TemporalAmount).

Temporal copiedTemporal = temporal.plus(duration);

Temporal copiedTemporal = duration.addTo(temporal);
Zum Beispiel:
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
Am 1. Januar 1986 gab die nepalesische Regierung ihre Zeitzone als +5:45 GMT bekannt. Damit sind sie 15 Minuten schneller als das benachbarte Indien. Diese Aktion soll bei dem riesigen Nachbarn etwas bewegen und den Nationalstolz des nepalesischen Volkes zeigen.
So entspricht der 1. Januar 1986 bei 0 Stunden 0 Minuten 0 Sekunden in Indien 0 Stunden 15 Minuten 0 Sekunden in Nepal. Die Nepalesen haben ihre Uhren 15 Minuten schneller gedreht als die Inder.
Wir werden sehen, was am 31. Dezember 1985 um 23:30 Uhr in Nepal passiert und dann 1 Stunde später:
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)

Subtrahieren Sie diese Duration vom angegebenen Objekt Temporal und geben Sie eine Kopie dieses Objekts Temporal zurück.

// Inherited from TemporalAmount interface
public Temporal subtractFrom(Temporal temporal)  
Diese Methode entspricht der Methode Temporal.minus(TemporalAmount).

Temporal copiedTemporal = temporal.minus(duration);

Temporal copiedTemporal = duration.subtractFrom(temporal);
Zum Beispiel:
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)

Multiplizieren Sie diese Duration mit einem angegebenen Wert und geben Sie eine neue Duration zurück. Das zurückgegebene Ergebnis wird normalisiert.

public Duration multipliedBy(long multiplicand)
Zum Beispiel:
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)

Diese Duration wird durch einen angegebenen Wert dividiert und gibt eine neue Duration zurück. Das zurückgegebene Ergebnis wird normalisiert.

public Duration dividedBy(long divisor)
Zum Beispiel:
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)

Teilen Sie diese Duration durch eine andere Duration und geben Sie einen Integer zurück.

public long dividedBy(Duration divisor)
Zum Beispiel:
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

View more Tutorials:

Vielleicht bist du interessiert

Das sind die Online-Courses außer der Website o7planning, die wir empfehlen. Sie können umsonst sein oder Discount haben.