Java Duration-Klasse

Die Duration-Klasse ist eine wichtige Klasse im Datums-/Zeit-API (java.time-Paket), das in Java 8 eingeführt wurde, und wird verwendet, um Zeitintervalle oder Zeitdauern darzustellen.

Die Duration-Klasse wird hauptsächlich verwendet, um die Differenz zwischen zwei Zeitpunkten zu berechnen oder eine bestimmte Zeitspanne darzustellen.

Grundlegende Konzepte

Das von der Duration-Klasse dargestellte Zeitintervall kann auf Nanosekunden genau sein. Es wird hauptsächlich verwendet, um zeitbasierte Größen (Stunden, Minuten, Sekunden und Nanosekunden) zu verarbeiten, ohne die Konzepte von Datum oder Zeitzone einzubeziehen.

Hauptfunktionen:

  1. Unveränderlichkeit - Sobald ein Duration-Objekt erstellt wurde, kann es nicht geändert werden
  2. Thread-Sicherheit - Kann sicher in Multithread-Umgebungen verwendet werden
  3. Hohe Präzision - Kann auf Nanosekunden genau sein
  4. Verkettete Aufrufe - Unterstützt Methodenverkettung

Duration-Objekte erstellen

Die Duration-Klasse bietet mehrere statische Methoden zum Erstellen von Duration-Instanzen:

1. Erstellen über Zeiteinheiten

Beispiel

// Erstellt eine Duration, die 2 Stunden dauert
Duration twoHours = Duration.ofHours(2);

// Erstelle eine Duration, die 30 Minuten dauert
Duration thirtyMinutes = Duration.ofMinutes(30);

// Erstelle eine Duration, die 45 Sekunden dauert
Duration fortyFiveSeconds = Duration.ofSeconds(45);

// Erstelle eine Duration, die 500 Millisekunden dauert
Duration fiveHundredMillis = Duration.ofMillis(500);

// Erstelle eine Duration, die 1,000,000 Nanosekunden dauert
Duration oneMillionNanos = Duration.ofNanos(1_000_000);

2. Erstellen über Zeitmenge

Beispiel

// Erstelle eine Duration, die 1 Tag, 2 Stunden und 3 Minuten dauert
Duration customDuration = Duration.ofDays(1).plusHours(2).plusMinutes(3);

3. Berechnung anhand von zwei Zeitpunkten

Beispiel

Instant start = Instant.now();
// Einige Operationen ausführen...
Instant end = Instant.now();
Duration elapsed = Duration.between(start, end);

4. Erstellen durch Parsen einer Zeichenkette

Beispiel

// Aus einer Zeichenkette im ISO-8601-Format erstellen
Duration parsedDuration = Duration.parse("PT2H30M15S"); // 2 Stunden, 30 Minuten, 15 Sekunden

Häufige Methoden

Die Klasse Duration bietet umfangreiche Methoden zum Umgang mit Zeitintervallen:

1. Abrufen von Zeitwerten

Beispiel

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. Zeitoperationen

Beispiel

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

// Addition
Duration sum = d1.plus(d2);  // 2 Stunden 30 Minuten

// Subtraktion
Duration diff = d1.minus(d2); // 1 Stunde 30 Minuten

// Multiplikation
Duration multipliziert = d1.multipliedBy(3); // 6 hours

// Division
Duration geteilt = d1.dividedBy(2); // 1 hour

3. Vergleichsoperationen

Beispiel

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. Weitere praktische Methoden

Beispiel

Duration duration = Duration.ofMinutes(90);

// In andere Einheiten umrechnen
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

// Jeden Teil abrufen
long secondsPart = duration.getSeconds(); // 5400
int nanoPart = duration.getNano();       // 0

// Absoluten Wert abrufen
Duration absDuration = duration.abs();

// Negativen Wert abrufen
Duration negated = duration.negated();

Praktische Anwendungsbeispiele

Beispiel 1: Berechnung der Codeausführungszeit

Beispiel

Instant start = Instant.now();

// Simuliere eine zeitaufwändige Operation
try {
    Thread.sleep(1500);
} catch (InterruptedException e) {
    e.printStackTrace();
}

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

System.out.println("Code-Ausführungszeit: " + elapsed.toMillis() + " Millisekunden");

Beispiel 2: Zeitformatkonvertierung

Beispiel

Duration duration = Duration.ofMinutes(135);

// In das Format "HH:MM:SS" umwandeln
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); // Ausgabe: 02:15:00

Beispiel 3: Timeout-Steuerung

Beispiel

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

while (true) {
    // Prüfen, ob eine Zeitüberschreitung aufgetreten ist
    if (Duration.between(startTime, Instant.now()).compareTo(timeout) > 0) {
        System.out.println("Zeitüberschreitung bei der Operation");
        break;
    }
   
    // Weitere Operationen ausführen...
}

Beispiel

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

public class DurationDemo {
    public static void main(String[] args) {
        // Verschiedene Möglichkeiten, Duration-Objekte zu erstellen
       
        // 1. Verwenden Sie die of...()-Methode
        Duration duration1 = Duration.ofHours(2); // 2 Stunden
        Duration duration2 = Duration.ofMinutes(90); // 90 Minuten
        System.out.println("Dauer 1: " + duration1);
        System.out.println("Dauer 2: " + duration2);
       
        // 2. Verwenden Sie die between()-Methode, um die Dauer zwischen zwei Zeitpunkten zu berechnen
        LocalTime startTime = LocalTime.of(9, 0);
        LocalTime endTime = LocalTime.of(11, 30);
        Duration duration3 = Duration.between(startTime, endTime);
        System.out.println("Dauer zwischen den Zeiten: " + duration3);
       
        // 3. Verwenden Sie die parse()-Methode, um eine Dauer aus einer Zeichenkette zu erstellen
        Duration duration4 = Duration.parse("PT2H30M"); // ISO-8601-Format
        System.out.println("Geparste Dauer: " + duration4);
       
        // 4. Verwenden Sie Instant, um die Zeitdifferenz zu berechnen
        Instant startInstant = Instant.now();
        // Simuliere eine zeitaufwändige Operation
        try { Thread.sleep(1500); } catch (InterruptedException e) {}
        Instant endInstant = Instant.now();
        Duration duration5 = Duration.between(startInstant, endInstant);
        System.out.println("Ausführungsdauer: " + duration5.toMillis() + "ms");
    }
}

Das Ausgabeergebnis ist:

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

Hinweise

  1. Präzisionsproblem: Die Duration kann bis auf Nanosekundenebene genau sein, aber die tatsächliche Präzision hängt von der Unterstützung des Betriebssystems und der Hardware ab.

  2. Unterschied zu Period：

    • Duration wird verwendet, um zeitbasierte Stunden, Minuten und Nanosekunden zu messen
    • Period wird verwendet, um datumsbasierte Jahre, Monate und Tage zu messen

  3. Unveränderlichkeit: Alle Duration-Objekte sind unveränderlich; jede Änderungsoperation gibt eine neue Duration-Instanz zurück.

  4. Umgang mit negativen Werten: Duration kann negative Zeitintervalle darstellen, die bei der Berechnung von Zeitdifferenzen auftreten können.

  5. Zeichenfolgenformat: Verwendet das ISO-8601-DauerformatPnDTnHnMn.nS, wobei:

    • P ist der Dauer-Designator
    • D ist die Anzahl der Tage
    • T ist das Trennzeichen für den Zeitteil
    • H ist die Anzahl der Stunden
    • M ist die Anzahl der Minuten
    • S ist die Anzahl der Sekunden (kann einen Bruchteil haben)

Zusammenfassung

Die Duration-Klasse von Java bietet leistungsstarke und flexible Werkzeuge für Zeitintervalle. Durch die Beherrschung der Verwendung der Duration-Klasse können Entwickler verschiedene zeitrechnungsbezogene Anforderungen leichter bewältigen, wie z. B. Leistungsmessung, Timeout, Aufgabenplanung usw. In Kombination mit anderen in Java 8 eingeführten Datums-/Uhrzeitklassen (wie Instant, LocalDateTime usw.) kann die Duration-Klasse robusteren und besser lesbaren Code zur Zeitverarbeitung erstellen.

Andere Erweiterungen