devstory

Le Tutoriel de Java Duration

View more Tutorials:

Suivez-nous sur notre fanpage pour recevoir des notifications chaque fois qu'il y a de nouveaux articles. Facebook

1- Duration

La classe Duration représente une durée avec une précision à la nanoseconde. Par exemple : "2 jours 3 heures", "2 heures 3 minutes 15 secondes", "2 secondes 123 nanosecondes",..

public final class Duration
        implements TemporalAmount, Comparable<Duration>, Serializable
  • ChronoPeriod
  • Period
  • TemporalAmount
Les classes Duration et Period représentent toutes deux une quantité de temps, mais elles présentent des différences. La Duration représente une durée exacte, alors que la Period représente une durée estimée.
  • La Duration peut être convertie en NANOS, MILLIS, SECONDS, MINITES, HOURS ou DAYS. Ces unités sont précises, 1 jour étant considéré comme 24 heures.
  • La Period prend en charge les unités DAYS, MONTHS, YEARS qui sont indépendantes les unes des autres. La raison en est que ces unités sont des estimations, elles ne sont pas de longueur fixe.
Par exemple:
  Example
Duration 1 days 23 hours 15 seconds
Period 3 years 5 months 1 days
Les valeurs de jour, heure, minute, seconde, milliseconde, nanoseconde dans la Duration peuvent être converties les unes aux autres. Par exemple, "13 heures et 90 minutes" équivaut à "14 heures et 30 minutes".
Bien que la Duration soit une classe basée sur le nombre de nanosecondes, afin de comparer 2 objets Duration, vous devez utiliser la méthode equals(Object).

2- Factory methods

Les méthodes de fabrique statiques :

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)
Par exemple : Créer une Duration à partir de secondes et de nanosecondes :
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
Par exemple : Créer une Duration qui est l'intervalle de temps entre 2 objets Temporal. Remarque : ces deux objets Temporal doivent prendre en charge ChronoUnit.SECONDS, sinon une exception sera levée. Pour une précision maximale, ChronoUnit.NANOS ou ChronoField.NANO_OF_SECOND doit être pris en charge.
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

Les autres méthodes:

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

La méthode toNanos() renvoie le nombre total de nanosecondes dans cette Duration.
D'autres méthodes comme toMillis(), toSeconds(), toMinutes(), toHours(), toDays() sont également interprétées comme leurs noms indiquent.

public long toNanos()  
public long toMillis()  
public long toSeconds()  
public long toMinutes()  
public long toHours()  
public long toDays() 
Précisément, on a:
  • toMinutes() est égal à la partie intégrale de la division toSeconds() par 60.
  • toHours() est égal à la partie intégrale de la division toSeconds() par 60*60.
  • toDays() est égal à la partie intégrale de la division toSeconds() par 24*60*60.
(*) Si toNanos() > Long.MAX_VALUE ou toMillis() > Long.MAX_VALUE alors ArithmeticException sera levée.
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)
Par exemple:
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() *

La méthode toNanosPart() renvoie la partie nanoseconde de cette Duration, qui n'est pas le total des nanosecondes dans la Duration.
Les méthodes toMillisPart(), toMinutesPart(), toHoursPart() sont également interprétées comme leurs noms indiquent.
La méthode toDaysPart() renvoie le même résultat que 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
Par exemple:
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()

Renvoyer true si le nombre total de nanosecondes dans cette Duration est 0, sinon renvoie false.

public boolean isZero() 
Par exemple:
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()

Renvoyer true si le nombre total de nanosecondes dans cette Duration est inférieur à 0, sinon renvoyer false.

public boolean isNegative()  
Par exemple:
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)

Cette méthode ne prend en charge que 2 unités, ChronoUnit.SECONDS et ChronoUnit.NANOS. Les autres unités lèveront une exception.
  • get(ChronoUnit.SECONDS) renvoie le nombre total de secondes dans cette Duration, ce qui équivaut à toSeconds().
  • get(ChronoUnit.NANOS) renvoie la partie nanoseconde dans cette Duration, ce qui équivaut à toNanosPart(), la valeur est comprise entre 0 et 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
Par exemple:
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()

Renvoyer les unités prises en charge par cette Duration.

// Inherited from TemporalAmount interface
public List<TemporalUnit> getUnits()
Cette méthode renvoie toujours List.of(ChronoUnit.SECONDS,ChronoUnit.NANOS).

10- getX() *

La méthode getSeconds() renvoie le nombre total de secondes dans cette Duration, ce qui est similaire à la méthode toSeconds().
La méthode getNano() renvoie la partie nanoseconde de cette Duration, qui est la même que la méthode 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
Par exemple:
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)
La méthode withSeconds(seconds) renvoie une copie de cette Duration, en préservant les nanosecondes et en remplaçant le nombre total de secondes par les secondes données.
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)
La méthode withNanos(nanos) renvoie une copie de cette Duration, remplace la partie nanoseconde et conserve les autres. Le paramètre nanos dispose d'une valeur de 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)

Ajouter cette Duration avec une Duration spécifiée pour créer une nouvelle Durtion. Le résultat renvoyé est normalisé.

public Duration plus(Duration duration)  
Par exemple:
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)

Renvoyer une copie de cette Duration avec une quantité de temps ajoutée dans l'unité donnée.

public Duration plus(long amountToAdd, TemporalUnit unit)  
Remarque : Cette méthode ne prend en charge que les TemporalUnit(s) avec une durée exacte. Par exemple ChronoUnit.DAYS équivaut à 24 heures. ChronoUnit.MONTHS est considéré comme une estimation car sa durée n'est pas fixe. En conclusion, une temporalUnit est prise en charge par cette méthode si temporalUnit.isDurationEstimated() renvoie false.
Les unités standard suivantes sont prises en charge :
  • ChronoUnit.NANOS
  • ChronoUnit.MICROS
  • ChronoUnit.MILLIS
  • ChronoUnit.SECONDS
  • ChronoUnit.MINUTES
  • ChronoUnit.HOURS
  • ChronoUnit.HALF_DAYS
  • ChronoUnit.DAYS
Par exemple:
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(..) *

La méthode plusNanos(nanosToAdd) renvoie une copie de cette Duration avec le nombre spécifié de nanosecondes ajoutées.
D'autres méthodes comme plusMillis(millisToAdd), plusSeconds(secondsToAdd), plusMinutes(long minutesToAdd), plusHours(hoursToAdd), plusDays(daysToAdd) sont également interprétées de la même manière que leurs noms indiquent.

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)
Par exemple:
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)

Soustraire une Duration spécifiée de cette Duration et renvoyer une nouvelle Duration. Le résultat renvoyé est normalisé.

public Duration minus(Duration duration)  
Par exemple:
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)

Renvoyer une copie de cette Duration avec la durée spécifiée soustraite dans l'unité donnée.

public Duration minus(long amountToSubtract, TemporalUnit unit)
Remarque : Cette méthode ne prend en charque que les TemporalUnit(s) ayant une durée exacte. Par exemple, ChronoUnit.DAYS est l'équivalent de 24 heures. ChronoUnit.MONTHS est considéré comme une unité d'estimation (estimate) parce que sa longueur n'est pas fixe. En somme, une temporalUnit est pris en charge par cette méthode si temporalUnit.isDurationEstimated() renvoie false.
Les unités standard suivantes sont pris en charge :
  • ChronoUnit.NANOS
  • ChronoUnit.MICROS
  • ChronoUnit.MILLIS
  • ChronoUnit.SECONDS
  • ChronoUnit.MINUTES
  • ChronoUnit.HOURS
  • ChronoUnit.HALF_DAYS
  • ChronoUnit.DAYS
Par exemple:
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(..) *

La méthode minusNanos(nanosToSubtract) renvoie une copie de cette Duration avec la quantité spécifiée de nanosecondes soustraite.
D'autres méthodes telles que minusMillis(millisToSubtract), minusSeconds(secondsToSubtract), minusMinutes(long minutesToSubtract), minusHours(hoursToSubtract), minusDays(daysToSubtract) sont également interprétées de la même manière que leurs noms indiquent.

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)
Par exemple:
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)

Renvoyer une copie de cet objet Duration tronqué (truncated) à l'unité spécifiée.

public Duration truncatedTo(TemporalUnit unit)
Cette méthode prend en charge ChronoUnit.DAYS et toutes les unités basées sur le temps, ce qui signifie que temporalUnit.isTimeBased() est true. Les autres unités lèveront une exception.
Par exemple:
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()

Renvoyer une copie négative de cette Duration. C'est-à-dire, l'addition de la Duration renoyée et cette Duration est égale à 0.

public Duration negated()  
Par exemple:
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()

Renvoyer une copie de la valeur absolue de cette Duration, c'est-à-dire la longueur de la Duration renvoyée dispose d'une valeur positive.

public Duration abs()  
Par exemple:
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)

Ajouter cette Duration à un objet Temporal spécifié et renvoyer une copie de cet objet Temporal.

// Inherited from TemporalAmount interface
public Temporal addTo(Temporal temporal)
Cette méthode est l'équivalent de la méthode Temporal.plus(TemporalAmount).

Temporal copiedTemporal = temporal.plus(duration);

Temporal copiedTemporal = duration.addTo(temporal);
Par exemple:
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
Le 1er janvier 1986, le gouvernement népalais a annoncé son fuseau horaire à +5:45 GMT. Cela signifie qu'ils sont à 15 minutes plus rapides que l'Inde voisine. Cette action a pour but de faire la différence avec le voisin géant et de montrer la fierté nationale du peuple népalais.
Ainsi, le 1er janvier 1986, à 0 heures 0 minutes 0 secondes en Inde équivaut à 0 heures 15 minutes 0 secondes au Népal. Les Népalais ont tourné leurs horloges 15 minutes plus vite que les Indiens.
Nous verrons ce qui se passe à 23h30 le 31 décembre 1985 au Népal, puis 1 heure plus tard :
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)

Soustraire cette Duration de l'objet Temporal spécifié et renvoyer une copie de cet objet Temporal.

// Inherited from TemporalAmount interface
public Temporal subtractFrom(Temporal temporal)  
Cette méthode est équivalente à la méthode Temporal.minus(TemporalAmount).

Temporal copiedTemporal = temporal.minus(duration);

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

Multiplier cette Duration par une valeur spécifiée et renvoyer une nouvelle Duration. Le résultat renvoyé est normalisé.

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

Cette Duration est divisée par une valeur spécifiée et renvoie une nouvelle Duration. Le résultat renvoyé est normalisé.

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

Diviser cette Duration à une autre Duration et renvoyer un nombre entier.

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

Peut-être que vous êtes intéressé

Voici des leçons en ligne à part du site web o7planning que nous recommandons. La liste comprend des leçons en ligne et celles en promo.