Classe Duration de Java

La classe Duration est une classe importante de l'API date-heure (package java.time) introduite dans Java 8, utilisée pour représenter des intervalles de temps ou des durées.

La classe Duration est principalement utilisée pour calculer la différence entre deux points dans le temps, ou pour représenter une durée spécifique.

Concepts de base

L'intervalle de temps représenté par la classe Duration peut être précis à la nanoseconde près. Elle est principalement utilisée pour gérer des quantités temporelles (heures, minutes, secondes et nanosecondes), sans impliquer les concepts de dates ou de fuseaux horaires.

Fonctionnalités principales:

  1. Immuabilité - Une fois qu'un objet Duration est créé, il ne peut pas être modifié
  2. Sécurité des threads - Peut être utilisé en toute sécurité dans des environnements multithread
  3. Haute précision - Peut être précis à la nanoseconde près
  4. Appels chaînés - Prend en charge le chaînage de méthodes

Création d'objets Duration

La classe Duration fournit plusieurs méthodes statiques pour créer des instances de Duration :

1. Création via des unités de temps

Exemple

// Créer une Duration d'une durée de 2 heures
Duration twoHours = Duration.ofHours(2);

// Créer une Duration qui dure 30 minutes
Duration thirtyMinutes = Duration.ofMinutes(30);

// Créer une Duration qui dure 45 secondes
Duration fortyFiveSeconds = Duration.ofSeconds(45);

// Créer une Duration qui dure 500 millisecondes
Duration fiveHundredMillis = Duration.ofMillis(500);

// Créer une Duration qui dure 1,000,000 nanosecondes
Duration oneMillionNanos = Duration.ofNanos(1_000_000);

2. Création via une quantité de temps

Exemple

// Créer une Duration qui dure 1 jour, 2 heures et 3 minutes
Duration customDuration = Duration.ofDays(1).plusHours(2).plusMinutes(3);

3. Calcul via deux points temporels

Exemple

Instant start = Instant.now();
// Effectuer quelques opérations...
Instant end = Instant.now();
Duration elapsed = Duration.between(start, end);

4. Création en analysant une chaîne

Exemple

// Créer à partir d'une chaîne au format ISO-8601
Duration parsedDuration = Duration.parse("PT2H30M15S"); // 2 heures, 30 minutes, 15 secondes

Méthodes courantes

La classe Duration fournit des méthodes riches pour gérer les intervalles de temps :

1. Obtention des valeurs temporelles

Exemple

Duration duration = Duration.ofHours(2).plusMinutes(30);

long hours = duration.toHours();      // 2
long minutes = duration.toMinutes();  // 150
long seconds = duration.getSeconds(); // 9000
int nanos = duration.getNano();      // 0

2. Opérations temporelles

Exemple

Duration d1 = Duration.ofHours(2);
Duration d2 = Duration.ofMinutes(30);

// Addition
Duration sum = d1.plus(d2);  // 2 heures 30 minutes

// Soustraction
Duration diff = d1.minus(d2); // 1 heure 30 minutes

// Multiplication
Duration multiplied = d1.multipliedBy(3); // 6 heures

// Division
Duration divided = d1.dividedBy(2); // 1 heure

3. Opérations de comparaison

Exemple

Duration d1 = Duration.ofHours(1);
Duration d2 = Duration.ofMinutes(90);

boolean isEqual = d1.equals(d2);      // false
int comparison = d1.compareTo(d2);    // -1 (d1 < d2)
boolean isNegative = d1.isNegative(); // false
boolean isZero = d1.isZero();         // false

4. Autres méthodes pratiques

Exemple

Duration duration = Duration.ofMinutes(90);

// Convertir en d'autres unités
long hours = duration.toHours();      // 1
long minutes = duration.toMinutes();  // 90
long seconds = duration.toSeconds();  // 5400
long millis = duration.toMillis();    // 5400000
long nanos = duration.toNanos();      // 5400000000000

// Obtenir chaque partie
long secondsPart = duration.getSeconds(); // 5400
int nanoPart = duration.getNano();       // 0

Obtenir la valeur absolue
Duration absDuration⟦⟧duration. = duration.abs();

// Obtenir la valeur négative
Duration negated = duration.negated();

Exemples d'applications pratiques

Exemple 1 : Calcul du temps d'exécution du code

Exemple

Instant start = Instant.now();

// Simuler une opération chronophage
try {
    Thread.sleep(1500);
} catch (InterruptedException e) {
    e.printStackTrace();
}

Instant end = Instant.now();
Duration elapsed = Duration.between(start, end);

System.out.println("Temps d'exécution du code : " + elapsed.toMillis() + " milliseconds");

Exemple 2 : Conversion du format de l'heure

Exemple

Duration duration = Duration.ofMinutes(135);

// Convertir au format "HH:MM:SS"
long hours = duration.toHours();
long minutes = duration.minusHours(hours).toMinutes();
long seconds = duration.minusHours(hours).minusMinutes(minutes).getSeconds();

String formatted = String.format("%02d:%02d:%02d", hours, minutes, seconds);
System.out.println(formatted); // Sortie : 02:15:00

Exemple 3 : Contrôle du délai d'attente

Exemple

Duration timeout = Duration.ofSeconds(30);
Instant startTime = Instant.now();

while (true) {
    // Vérifier si le délai a expiré
    if (Duration.between(startTime, Instant.now()).compareTo(timeout) > 0) {
        System.out.println("L'opération a expiré");
        break;
    }
   
    // Effectuer d'autres opérations...
}

Exemple

import java.time.Duration;
import java.time.LocalTime;
import java.time.Instant;

public class DurationDemo {
    public static void main(String[] args) {
        // Plusieurs façons de créer des objets Duration
       
        // 1. Utiliser la méthode of...()
        Duration duration1 = Duration.ofHours(2); // 2 heures
        Duration duration2 = Duration.ofMinutes(90); // 90 minutes
        System.out.println("Durée 1 : " + duration1);
        System.out.println("Durée 2 : " + duration2);
       
        // 2. Utilisez la méthode between() pour calculer la durée entre deux points dans le temps
        LocalTime startTime = LocalTime.of(9, 0);
        LocalTime endTime = LocalTime.of(11, 30);
        Duration duration3 = Duration.between(startTime, endTime);
        System.out.println("Durée entre les instants : " + duration3);
       
        // 3. Utilisez la méthode parse() pour créer à partir d'une chaîne
        Duration duration4 = Duration.parse("PT2H30M"); // format ISO-8601
        System.out.println("Durée analysée : " + duration4);
       
        // 4. Utilisez Instant pour calculer la différence temporelle
        Instant startInstant = Instant.now();
        // Simuler une opération chronophage
        try { Thread.sleep(1500); } catch (InterruptedException e) {}
        Instant endInstant = Instant.now();
        Duration duration5 = Duration.between(startInstant, endInstant);
        System.out.println("Durée d'exécution : " + duration5.toMillis() + "ms");
    }
}

Le résultat de sortie est:

Duration 1: PT2H
Duration 2: PT1H30M
Duration between times: PT2H30M
Parsed Duration: PT2H30M
Execution duration: 1501ms

Notes

  1. Problème de précision: La Duration peut être précise au niveau de la nanoseconde, mais la précision réelle dépend du support du système d'exploitation et du matériel.

  2. Différence avec Period：

    • Duration est utilisé pour mesurer des unités temporelles telles que les heures, les minutes, les secondes et les nanosecondes.
    • Period est utilisé pour mesurer des unités basées sur les dates telles que les années, les mois et les jours.

  3. Immutabilité: Tous les objets Duration sont immuables ; toute opération de modification renvoie une nouvelle instance de Duration.

  4. Gestion des valeurs négatives: Duration peut représenter des intervalles de temps négatifs, qui peuvent être rencontrés lors du calcul de différences de temps.

  5. Format de chaîne: Utilise le format de durée ISO-8601PnDTnHnMn.nS, où :

    • P est le désignateur de durée
    • D est le nombre de jours
    • T est le séparateur pour la partie temps
    • H est le nombre d'heures
    • M est le nombre de minutes
    • S est le nombre de secondes (peut avoir une partie fractionnaire)

Résumé

La classe Duration de Java fournit des outils puissants et flexibles pour gérer les intervalles de temps. En maîtrisant l'utilisation de la classe Duration, les développeurs peuvent plus facilement répondre à diverses exigences liées au calcul du temps, telles que la mesure des performances, le contrôle des délais d'attente, la planification des tâches, etc. Utilisée conjointement avec d'autres classes de date et d'heure introduites dans Java 8 (telles que Instant, LocalDateTime, etc.), la classe Duration permet de construire un code de gestion du temps plus robuste et plus lisible.

Autres extensions