Deutsch

Java-Tutorial

Java-Steuersätze

Objektorientierte Programmierung

Java eingebettete Klassen

Java-Dateiverwaltung

Java-Fehler & Ausnahmen

Java Multithreading

Java Synchronisation

Java-Netzwerk

Java Sammlungen

Java-Schnittstellen

Java-Datenstrukturen

Java Collections-Algorithmen

Fortgeschrittenes Java

Java Verschiedenes

Java-Klassenreferenzen

Java 8 - Neue Datum-und-Zeit-API

Hallo zusammen, zukünftige Java-Zauberer! ? Heute machen wir uns auf eine aufregende Reise durch die magische Welt von Java's Datum-und-Zeit-API. Keine Sorge, wenn ihr noch nie eine Zeile Code geschrieben habt - wir beginnen ganz am Anfang und arbeiten gemeinsam hinauf. Bis zum Ende dieser Lektion werdet ihr mit Datum und Zeit wie ein Profi jonglieren können! Also, tauchen wir ein!

Java - Datetime Api

Einführung in Java's Datum-und-Zeit-API

Stellen wir uns vor, du baust eine Zeitmaschine (cool, oder?). Um sie zum Laufen zu bringen, müsstest du Datum und Zeit mit Präzision behandeln. Genau das hilft uns Java's Datum-und-Zeit-API in unseren Programmen zu tun. Es ist wie ein supergenauer Wecker und Kalender in einem!

Warum eine neue API?

Bevor wir ins Detail gehen, fragst du dich vielleicht, "Warum hat Java eine neue Datum-und-Zeit-API geschaffen?" Lass mich dir eine kleine Geschichte erzählen.

Es war einmal (vor Java 8), mussten Entwickler die alten java.util.Date und java.util.Calendar Klassen verwenden. Diese waren wie die Nutzung einer alten, rostigen Uhr - sie funktionierten, aber sie hatten viele Probleme. Sie waren schwer zu bedienen, nicht threadsicher (was bedeutet, sie konnten in komplexen Programmen Probleme verursachen) und haben Zeitzone nicht gut behandelt.

Also entschied sich das Java-Team, eine brandneue, glänzende API zu schaffen, die all diese Probleme löst. Und so wurde das java.time Paket in Java 8 geboren!

Java Lokale Datum-und-Zeit-API

Fangen wir mit den Grundlagen an. Die Lokale Datum-und-Zeit-API hilft uns, mit Datum und Zeit ohne Zeitzone umzugehen. Es ist wie ein einfaches Uhr und Kalender auf deinem Schreibtisch.

LocalDate

LocalDate repräsentiert ein Datum ohne Zeitzone. Sehen wir uns an, wie man es verwendet:

import java.time.LocalDate;

public class DateExample {
public static void main(String[] args) {
LocalDate today = LocalDate.now();
System.out.println("Heutiges Datum ist: " + today);

LocalDate specificDate = LocalDate.of(2023, 6, 15);
System.out.println("Ein spezifisches Datum: " + specificDate);
}
}

In diesem Beispiel tun wir zwei Dinge:

  1. Wir holen das heutige Datum mit LocalDate.now().
  2. Wir erstellen ein spezifisches Datum (15. Juni 2023) mit LocalDate.of().

Wenn du diesen Code ausführst, siehst du das heutige Datum und das spezifische Datum, das wir erstellt haben, ausgegeben.

LocalTime

LocalTime repräsentiert eine Zeit ohne Datum oder Zeitzone. Hier ist, wie wir es verwenden können:

import java.time.LocalTime;

public class TimeExample {
public static void main(String[] args) {
LocalTime now = LocalTime.now();
System.out.println("Die aktuelle Zeit ist: " + now);

LocalTime specificTime = LocalTime.of(14, 30, 45);
System.out.println("Eine spezifische Zeit: " + specificTime);
}
}

In diesem Beispiel:

  1. Wir holen die aktuelle Zeit mit LocalTime.now().
  2. Wir erstellen eine spezifische Zeit (14:30:45) mit LocalTime.of().

LocalDateTime

LocalDateTime kombiniert sowohl Datum als auch Zeit, aber immer noch ohne Zeitzone. Es ist wie eine Uhr, die auch das Datum anzeigt. Hier ist, wie man es verwendet:

import java.time.LocalDateTime;

public class DateTimeExample {
public static void main(String[] args) {
LocalDateTime now = LocalDateTime.now();
System.out.println("Aktuelles Datum und Uhrzeit: " + now);

LocalDateTime specificDateTime = LocalDateTime.of(2023, 6, 15, 14, 30, 45);
System.out.println("Ein spezifisches Datum und Uhrzeit: " + specificDateTime);
}
}

In diesem Beispiel:

  1. Wir holen das aktuelle Datum und die Uhrzeit mit LocalDateTime.now().
  2. Wir erstellen ein spezifisches Datum und Uhrzeit (15. Juni 2023, 14:30:45) mit LocalDateTime.of().

Java Zeitbezogene Datum-und-Zeit-API

Jetzt geben wir unserer Zeitmaschine etwas Würze - Zeitzone! Die Zeitbezogene Datum-und-Zeit-API hilft uns, mit Datum und Zeit unter Berücksichtigung verschiedener Zeitzone umzugehen.

ZonedDateTime

ZonedDateTime repräsentiert ein datum-und-zeit mit einer Zeitzone. Es ist wie eine Weltuhr, die verschiedene Zeiten für verschiedene Weltteile anzeigt.

import java.time.ZonedDateTime;
import java.time.ZoneId;

public class ZonedDateTimeExample {
public static void main(String[] args) {
ZonedDateTime nowInSystemTZ = ZonedDateTime.now();
System.out.println("Aktuelles Datum und Uhrzeit im Systemszeitzone: " + nowInSystemTZ);

ZonedDateTime nowInParis = ZonedDateTime.now(ZoneId.of("Europe/Paris"));
System.out.println("Aktuelles Datum und Uhrzeit in Paris: " + nowInParis);
}
}

In diesem Beispiel:

  1. Wir holen das aktuelle datum-und-zeit im Systemszeitzone mit ZonedDateTime.now().
  2. Wir holen das aktuelle datum-und-zeit in Paris mit ZonedDateTime.now(ZoneId.of("Europe/Paris")).

Java Chrono-Einheiten Enum

Das ChronoUnit Enum bietet eine Reihe von Standard-Datenperioden und Zeiteneinheiten. Es ist wie verschiedene Messwerkzeuge für die Zeit - Sekunden, Minuten, Stunden, Tage, Wochen, Monate, Jahre und so weiter.

import java.time.LocalDateTime;
import java.time.temporal.ChronoUnit;

public class ChronoUnitExample {
public static void main(String[] args) {
LocalDateTime now = LocalDateTime.now();
LocalDateTime futureDateTime = now.plus(1, ChronoUnit.WEEKS);

long daysBetween = ChronoUnit.DAYS.between(now, futureDateTime);
System.out.println("Tage zwischen heute und einer Woche von jetzt: " + daysBetween);
}
}

In diesem Beispiel:

  1. Wir fügen eine Woche zur aktuellen datum-und-zeit hinzu mit plus(1, ChronoUnit.WEEKS).
  2. Wir berechnen die Anzahl der Tage zwischen heute und einer Woche von jetzt mit ChronoUnit.DAYS.between().

Java Periode und Dauer

Period und Duration werden verwendet, um Mengen an Zeit darzustellen. Denke von Period als Unterschied zwischen zwei Daten auf einem Kalender und Duration als die Zeit, die auf einem Stoppuhr angezeigt wird.

import java.time.LocalDate;
import java.time.Period;
import java.time.Duration;
import java.time.LocalTime;

public class PeriodDurationExample {
public static void main(String[] args) {
LocalDate date1 = LocalDate.of(2023, 1, 1);
LocalDate date2 = LocalDate.of(2023, 12, 31);
Period period = Period.between(date1, date2);
System.out.println("Periode zwischen " + date1 + " und " + date2 + ": " + period);

LocalTime time1 = LocalTime.of(9, 0);
LocalTime time2 = LocalTime.of(17, 30);
Duration duration = Duration.between(time1, time2);
System.out.println("Dauer zwischen " + time1 + " und " + time2 + ": " + duration);
}
}

In diesem Beispiel:

  1. Wir berechnen die Periode zwischen zwei Daten mit Period.between().
  2. Wir berechnen die Dauer zwischen zwei Zeiten mit Duration.between().

Java Temporal Anpassungen

Temporal Anpassungen sind wie magische Zauberstäbe für Daten. Sie erlauben es dir, Daten auf nützliche Weise anzupassen, wie z.B. das nächste Montag oder den letzten Tag des Monats zu finden.

import java.time.LocalDate;
import java.time.temporal.TemporalAdjusters;

public class TemporalAdjustersExample {
public static void main(String[] args) {
LocalDate date = LocalDate.now();
LocalDate nextMonday = date.with(TemporalAdjusters.next(DayOfWeek.MONDAY));
System.out.println("Nächster Montag: " + nextMonday);

LocalDate lastDayOfMonth = date.with(TemporalAdjusters.lastDayOfMonth());
System.out.println("Letzter Tag dieses Monats: " + lastDayOfMonth);
}
}

In diesem Beispiel:

  1. Wir finden das Datum des nächsten Montags mit TemporalAdjusters.next(DayOfWeek.MONDAY).
  2. Wir finden den letzten Tag des aktuellen Monats mit TemporalAdjusters.lastDayOfMonth().

Rückwärtskompatibilität

Nun fragst du dich vielleicht, "Was ist mit all dem alten Code, der die alten Datum-und-Zeit-Klassen verwendet?" Keine Sorge! Java hat auch daran gedacht. Die neue API bietet Methoden zum Konvertieren zwischen den alten und neuen Datum-und-Zeit-Klassen.

import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.Date;

public class BackwardCompatibilityExample {
public static void main(String[] args) {
// Konvertieren alter Date zu neuer LocalDateTime
Date oldDate = new Date();
LocalDateTime newDateTime = LocalDateTime.ofInstant(oldDate.toInstant(), ZoneId.systemDefault());
System.out.println("Altes Datum: " + oldDate);
System.out.println("Neue LocalDateTime: " + newDateTime);

// Konvertieren neuer LocalDateTime zu altem Date
LocalDateTime localDateTime = LocalDateTime.now();
Date date = Date.from(localDateTime.atZone(ZoneId.systemDefault()).toInstant());
System.out.println("Neue LocalDateTime: " + localDateTime);
System.out.println("Altes Datum: " + date);
}
}

In diesem Beispiel:

  1. Wir konvertieren ein altes Date Objekt in ein neues LocalDateTime Objekt.
  2. Wir konvertieren ein neues LocalDateTime Objekt zurück in ein altes Date Objekt.

Diese Rückwärtskompatibilität stellt sicher, dass du noch mit älterem Java-Code arbeiten kannst, während du die Vorteile der neuen Datum-und-Zeit-API genießen kannst.

Schlussfolgerung

Herzlichen Glückwunsch! Du hast deine ersten Schritte in die Welt von Java's Datum-und-Zeit-API gemacht. Wir haben viel Boden coberter, von grundlegenden Datum-und-Zeit-Verarbeitung bis hin zu fortgeschritteneren Konzepten wie Zeitzone und temporalen Anpassungen.

Denke daran, wie jede Fähigkeit, das Beherrschen von Datum und Zeit in Java erfordert Übung. Lass dich nicht entmutigen, wenn es am Anfang überwältigend erscheint - selbst erfahrene Entwickler müssen manchmal nachschlagen, wie man diese Klassen verwendet!

Continuiere mit diesen Beispielen zu experimentieren, passe sie an und sieh, was passiert. Vor dir wirst du wie ein echter Java-Zeitreisender!

Happy Coding und möge deine Zeit immer perfekt sein! ⏰?

Credits: Image by storyset

Vorheriges Tutorial:
Java - Streams
Nächstes Tutorial:
Java 8 - Neue Funktionen