WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / Java

ZonedDateTime: Erzeugen, Umrechnen, Formatieren und Kalenderfelder ändern

Erzeuge Datums- und Uhrzeitwerte mit Zeitzone, rechne sie bei gleichem Zeitpunkt um, formatiere sie und ändere lokale Felder unter Beachtung von Zeitumstellungen.

Version: Java SE 21

Syntax

java.time.ZonedDateTime — Java SE 21
static ZonedDateTime of(LocalDateTime dateTime, ZoneId zone)
static ZonedDateTime of(LocalDate date, LocalTime time, ZoneId zone)
static ZonedDateTime of(int year, int month, int dayOfMonth, int hour, int minute, int second, int nanoOfSecond, ZoneId zone)
static ZonedDateTime ofInstant(Instant instant, ZoneId zone)
static ZonedDateTime ofInstant(LocalDateTime dateTime, ZoneOffset offset, ZoneId zone)
Instant toInstant() // inherited from ChronoZonedDateTime
ZonedDateTime withZoneSameInstant(ZoneId zone)
String format(DateTimeFormatter formatter)
ZonedDateTime with(TemporalAdjuster adjuster)
ZonedDateTime with(TemporalField field, long newValue)
ZonedDateTime withHour(int hour)
ZonedDateTime withMinute(int minute)

java.time.ZonedDateTime speichert ein lokales Datum mit Uhrzeit, eine Zonen-ID und den ermittelten UTC-Versatz. Die statische Methode ZonedDateTime.of nimmt ein LocalDateTime, ein Paar aus LocalDate und LocalTime oder sieben Ganzzahlen (year bis nanoOfSecond) entgegen, jeweils mit einer ZoneId. Wird die Uhr vorgestellt und fällt die lokale Zeit in eine Lücke, verschiebt die Methode sie um die Länge der Lücke nach vorn. Bei einer wiederholten lokalen Zeit wählt sie den Versatz für den früheren Zeitpunkt. Ungültige Zahlenfelder oder ein unmögliches Datum führen zu DateTimeException.

ZonedDateTime.ofInstant(Instant, ZoneId) ermittelt die lokale Datums- und Uhrzeitangabe sowie den Versatz für den gegebenen Zeitpunkt in der Zielzone. Die Überladung (LocalDateTime, ZoneOffset, ZoneId) bestimmt den Zeitpunkt zuerst aus der lokalen Angabe und dem übergebenen Versatz. Dann stellt sie ihn in der Zielzone dar; lokale Uhrzeit und Versatz können von der Eingabe abweichen. Die geerbte Methode ZonedDateTime.toInstant() liefert denselben Zeitpunkt ohne Zoneninformation. ZonedDateTime.withZoneSameInstant(ZoneId) behält den Zeitpunkt bei, kann aber Datum und Uhrzeit ändern. withZoneSameLocal versucht dagegen, Datum und Uhrzeit beizubehalten, und kann den Zeitpunkt ändern.

ZonedDateTime.format(DateTimeFormatter) gibt einen String zurück, ohne das Objekt zu ändern. ISO_OFFSET_DATE_TIME gibt lokales Datum, Uhrzeit und Versatz aus, aber keine regionale Zonen-ID. Schlägt die Formatierung fehl, löst die Methode DateTimeException aus.

ZonedDateTime.with(TemporalAdjuster) wendet eine Regel an, etwa TemporalAdjusters.lastDayOfMonth(). Die Überladung with(TemporalField, long) setzt ein unterstütztes Feld wie ChronoField.MONTH_OF_YEAR. INSTANT_SECONDS setzt die Sekunde auf der Zeitachse und behält Zone und Sekundenbruchteil bei. OFFSET_SECONDS kann nur bei einer wiederholten lokalen Zeit zum anderen gültigen Versatz wechseln. Ein nicht unterstütztes Feld kann UnsupportedTemporalTypeException auslösen, ein ungültiger Wert DateTimeException.

ZonedDateTime.withHour(int) setzt die Stunde (0–23), ZonedDateTime.withMinute(int) die Minute (0–59); beide addieren keine Zeitspanne. Werte außerhalb des Bereichs führen zu DateTimeException. Beim Ändern lokaler Felder bleibt die Zone gleich, der Zeitpunkt kann sich aber ändern. In einer Lücke wird das Ergebnis um deren Länge nach vorn verschoben. Bei wiederholter lokaler Zeit bleibt der bisherige Versatz erhalten, falls er gültig ist; sonst gilt der frühere Zeitpunkt. Die Objekte sind unveränderlich, speichere also den Rückgabewert.

Beispiele

import java.time.Instant;
import java.time.LocalDateTime;
import java.time.ZoneOffset;
import java.time.ZonedDateTime;
import java.time.format.DateTimeFormatter;
import java.time.temporal.ChronoField;
import java.time.temporal.TemporalAdjusters;

public class Main {
    public static void main(String[] args) {
        ZoneOffset east = ZoneOffset.of("+01:00");
        ZoneOffset west = ZoneOffset.of("-05:00");
        DateTimeFormatter iso = DateTimeFormatter.ISO_OFFSET_DATE_TIME;

        ZonedDateTime original = ZonedDateTime.of(
                LocalDateTime.of(2024, 1, 15, 10, 30), east);
        Instant instant = original.toInstant();
        ZonedDateTime converted = original.withZoneSameInstant(west);
        ZonedDateTime rebuilt = ZonedDateTime.ofInstant(instant, west);
        ZonedDateTime edited = original.with(ChronoField.MONTH_OF_YEAR, 2)
                .with(TemporalAdjusters.lastDayOfMonth())
                .withHour(14)
                .withMinute(45);

        System.out.println(original.format(iso));
        System.out.println(instant);
        System.out.println(converted.format(iso));
        System.out.println(converted.equals(rebuilt));
        System.out.println(edited.format(iso));
    }
}

Ergebnis

2024-01-15T10:30:00+01:00
2024-01-15T09:30:00Z
2024-01-15T04:30:00-05:00
true
2024-02-29T14:45:00+01:00

Die ersten drei Zeilen stellen denselben Zeitpunkt dar. `true` zeigt, dass beide Umrechnungen nach `-05:00` übereinstimmen. Die letzte Zeile zeigt die Kalenderänderung auf den 29. Februar um 14:45 mit dem ursprünglichen Versatz. Feste Versätze machen das Beispiel unabhängig von regionalen Zeitzonenregeln.

Zugehörige Lektionen

  • Java · Lektion 59 · Mittlere Stufe · Version: 2

Quellen