Java LocalDate: Aktuelles und nächstes Datum abrufen - Tutorial

Einführung

Dieses Tutorial führt Sie durch das Abrufen des aktuellen Datums und die Berechnung des Folgedatums unter Verwendung der Klasse LocalDate in Java. Die Java Time API, eingeführt in Java 8, bietet umfassende Funktionen zur Handhabung von Datum und Uhrzeit. Am Ende dieses Tutorials werden Sie verstehen, wie Sie LocalDate verwenden, um grundlegende Datumsoperationen effizient durchzuführen.

Das Java Time API und LocalDate verstehen

Bevor wir mit dem Programmieren beginnen, wollen wir uns mit der Klasse LocalDate vertraut machen und warum sie für die Handhabung von Daten in Java-Anwendungen nützlich ist.

Was ist das Java Time API?

Java 8 führte das Java Time API im Paket java.time ein, um die Einschränkungen älterer Datums- und Uhrzeitklassen zu beheben. Diese API bietet einen klareren und intuitiveren Ansatz für die Handhabung von Datum und Uhrzeit.

Einführung in LocalDate

Die Klasse LocalDate repräsentiert ein Datum ohne Zeitkomponente (Jahr, Monat, Tag). Sie ist unveränderlich (immutable), threadsicher und folgt dem ISO-8601-Kalendersystem.

Einige wichtige Vorteile der Verwendung von LocalDate sind:

Es bietet eine klare Trennung zwischen Datum-, Zeit- und Datums-Zeit-Konzepten.
Es bietet intuitive Methoden zur Datumsmanipulation.
Es verfügt über integrierte Unterstützung für verschiedene Datumsformate.
Es handhabt Datumsberechnungen korrekt.

Lassen Sie uns eine neue Java-Datei erstellen, um die Funktionalität von LocalDate zu erkunden.

Klicken Sie in der WebIDE auf das Explorer-Panel (das Symbol, das wie Seiten in der linken Seitenleiste aussieht).
Klicken Sie mit der rechten Maustaste im Dateiexplorer-Panel und wählen Sie "New File" (Neue Datei).
Benennen Sie die Datei DateExample.java und klicken Sie auf "OK".
Kopieren Sie die folgende grundlegende Codevorlage in die Datei:

public class DateExample {
    public static void main(String[] args) {
        // We will add our date code here
        System.out.println("Learning about LocalDate in Java");
    }
}

Speichern Sie die Datei, indem Sie Strg+S drücken oder im Menü Datei > Speichern auswählen.

Nachdem wir unsere Java-Datei erstellt haben, werden wir im nächsten Schritt Code hinzufügen, um mit dem aktuellen Datum zu arbeiten.

Abrufen des aktuellen Datums mit LocalDate

In diesem Schritt werden wir unser Java-Programm modifizieren, um das aktuelle Datum mithilfe der Klasse LocalDate abzurufen und anzuzeigen.

Importieren der LocalDate-Klasse

Zuerst müssen wir die Klasse LocalDate aus dem Paket java.time importieren. Öffnen Sie die Datei DateExample.java und fügen Sie die Importanweisung am Anfang hinzu:

import java.time.LocalDate;

public class DateExample {
    public static void main(String[] args) {
        // We will add our date code here
        System.out.println("Learning about LocalDate in Java");
    }
}

Verwendung der LocalDate.now() Methode

Die Klasse LocalDate stellt eine statische Methode namens now() bereit, die das aktuelle Datum zurückgibt. Ändern wir unseren Code, um das aktuelle Datum abzurufen und anzuzeigen:

import java.time.LocalDate;

public class DateExample {
    public static void main(String[] args) {
        // Get the current date
        LocalDate currentDate = LocalDate.now();

        // Display the current date
        System.out.println("Current date: " + currentDate);
    }
}

Kompilieren und Ausführen des Programms

Kompilieren und führen wir nun unser Programm aus:

Öffnen Sie ein Terminal in der WebIDE (Terminal > New Terminal aus dem Menü).
Navigieren Sie bei Bedarf zum Projektverzeichnis:
```
cd /home/labex/project
```
Kompilieren Sie das Java-Programm:
```
javac DateExample.java
```
Führen Sie das kompilierte Programm aus:
```
java DateExample
```

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Current date: 2023-04-12

Das tatsächliche Datum spiegelt das aktuelle Datum wider, wenn Sie das Programm ausführen.

Verstehen des Ausgabeformats

Die Standard-Zeichenkettenrepräsentation eines LocalDate-Objekts folgt dem ISO-8601-Format: YYYY-MM-DD. Dies ist ein internationaler Standard zur Darstellung von Daten.

Zum Beispiel repräsentiert 2023-04-12 den 12. April 2023.

Sie haben erfolgreich das aktuelle Datum mithilfe der Klasse LocalDate abgerufen und angezeigt. Im nächsten Schritt werden wir lernen, wie man das Folgedatum berechnet.

Berechnen des Folgedatums

Nachdem wir das aktuelle Datum abrufen können, werden wir lernen, wie man das Folgedatum berechnet, indem man einem LocalDate-Objekt Tage hinzufügt.

Verstehen der Datumsmanipulation mit LocalDate

Die Klasse LocalDate bietet verschiedene Methoden zur Datumsmanipulation, einschließlich:

plusDays(long days): Fügt die angegebene Anzahl von Tagen hinzu
plusWeeks(long weeks): Fügt die angegebene Anzahl von Wochen hinzu
plusMonths(long months): Fügt die angegebene Anzahl von Monaten hinzu
plusYears(long years): Fügt die angegebene Anzahl von Jahren hinzu

Es gibt auch entsprechende minus-Methoden für die Subtraktion.

Erweitern wir unseren Code, um das Folgedatum zu berechnen und anzuzeigen:

import java.time.LocalDate;

public class DateExample {
    public static void main(String[] args) {
        // Get the current date
        LocalDate currentDate = LocalDate.now();

        // Calculate the next date by adding one day
        LocalDate nextDate = currentDate.plusDays(1);

        // Display both dates
        System.out.println("Current date: " + currentDate);
        System.out.println("Next date: " + nextDate);
    }
}

Kompilieren und Ausführen des aktualisierten Programms

Kompilieren und führen wir unser aktualisiertes Programm aus:

Stellen Sie sicher, dass Sie die Änderungen an DateExample.java gespeichert haben.
Kompilieren Sie im Terminal das Java-Programm:
```
javac DateExample.java
```
Führen Sie das kompilierte Programm aus:
```
java DateExample
```

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Current date: 2023-04-12
Next date: 2023-04-13

Auch hier spiegeln die tatsächlichen Daten das aktuelle Datum wider, wenn Sie das Programm ausführen.

Erkunden anderer Datumsmanipulationen

Erweitern wir unser Programm weiter, um andere Datumsmanipulationsmethoden zu demonstrieren:

import java.time.LocalDate;

public class DateExample {
    public static void main(String[] args) {
        // Get the current date
        LocalDate currentDate = LocalDate.now();

        // Calculate various future dates
        LocalDate nextDate = currentDate.plusDays(1);
        LocalDate nextWeek = currentDate.plusWeeks(1);
        LocalDate nextMonth = currentDate.plusMonths(1);
        LocalDate nextYear = currentDate.plusYears(1);

        // Display all dates
        System.out.println("Current date: " + currentDate);
        System.out.println("Next date: " + nextDate);
        System.out.println("Date after one week: " + nextWeek);
        System.out.println("Date after one month: " + nextMonth);
        System.out.println("Date after one year: " + nextYear);
    }
}

Kompilieren und führen Sie das Programm erneut aus:

javac DateExample.java
java DateExample

Die Ausgabe zeigt das aktuelle Datum, das Folgedatum und Daten nach einer Woche, einem Monat und einem Jahr:

Current date: 2023-04-12
Next date: 2023-04-13
Date after one week: 2023-04-19
Date after one month: 2023-05-12
Date after one year: 2024-04-12

Wichtiges Konzept: Unveränderlichkeit (Immutability)

Beachten Sie, dass wir das Ergebnis von plusDays() einer neuen Variable zugewiesen haben. Dies liegt daran, dass LocalDate-Objekte unveränderlich (immutable) sind, was bedeutet, dass ihre Werte nach der Erstellung nicht geändert werden können. Methoden wie plusDays() modifizieren nicht das ursprüngliche Objekt; stattdessen geben sie ein neues Objekt mit dem aktualisierten Wert zurück.

Diese Unveränderlichkeit ist ein wichtiges Merkmal, das LocalDate-Objekte threadsicher und in komplexen Anwendungen vorhersagbarer macht.

Extrahieren von Datumskomponenten

In diesem Schritt werden wir lernen, wie man einzelne Komponenten von einem LocalDate-Objekt extrahiert, wie z.B. Tag, Monat, Jahr und Wochentag.

Methoden zur Extraktion von Datumskomponenten

Die Klasse LocalDate bietet verschiedene Methoden, um spezifische Komponenten eines Datums zu extrahieren:

getDayOfMonth(): Gibt den Tag des Monats zurück (1-31)
getMonthValue(): Gibt den Monat als Zahl zurück (1-12)
getMonth(): Gibt den Monat als Enum-Konstante zurück
getYear(): Gibt das Jahr zurück
getDayOfWeek(): Gibt den Wochentag als Enum-Konstante zurück

Erstellen wir eine neue Datei, um diese Methoden zu erkunden:

Erstellen Sie in der WebIDE eine neue Datei namens DateComponents.java
Fügen Sie den folgenden Code in die Datei ein:

import java.time.LocalDate;
import java.time.Month;
import java.time.DayOfWeek;

public class DateComponents {
    public static void main(String[] args) {
        // Get the current date
        LocalDate currentDate = LocalDate.now();

        // Extract date components
        int day = currentDate.getDayOfMonth();
        int monthValue = currentDate.getMonthValue();
        Month month = currentDate.getMonth();
        int year = currentDate.getYear();
        DayOfWeek dayOfWeek = currentDate.getDayOfWeek();

        // Display the components
        System.out.println("Current date: " + currentDate);
        System.out.println("Day of month: " + day);
        System.out.println("Month (number): " + monthValue);
        System.out.println("Month (name): " + month);
        System.out.println("Year: " + year);
        System.out.println("Day of week: " + dayOfWeek);
    }
}

Speichern Sie die Datei, indem Sie Strg+S drücken.

Kompilieren und Ausführen des Programms

Kompilieren und führen wir nun unser neues Programm aus:

Kompilieren Sie im Terminal das Java-Programm:
```
javac DateComponents.java
```
Führen Sie das kompilierte Programm aus:
```
java DateComponents
```

Sie sollten eine Ausgabe ähnlich der folgenden sehen:

Current date: 2023-04-12
Day of month: 12
Month (number): 4
Month (name): APRIL
Year: 2023
Day of week: WEDNESDAY

Erstellen eines spezifischen Datums

Zusätzlich zum Abrufen des aktuellen Datums können wir ein LocalDate-Objekt erstellen, das ein bestimmtes Datum darstellt, indem wir die Methode of() verwenden. Erweitern wir unser Programm, um ein bestimmtes Datum zu erstellen:

import java.time.LocalDate;
import java.time.Month;
import java.time.DayOfWeek;

public class DateComponents {
    public static void main(String[] args) {
        // Get the current date
        LocalDate currentDate = LocalDate.now();

        // Create a specific date
        LocalDate specificDate = LocalDate.of(2025, 12, 25);

        // Extract date components from the current date
        int day = currentDate.getDayOfMonth();
        int monthValue = currentDate.getMonthValue();
        Month month = currentDate.getMonth();
        int year = currentDate.getYear();
        DayOfWeek dayOfWeek = currentDate.getDayOfWeek();

        // Display the current date components
        System.out.println("Current date: " + currentDate);
        System.out.println("Day of month: " + day);
        System.out.println("Month (number): " + monthValue);
        System.out.println("Month (name): " + month);
        System.out.println("Year: " + year);
        System.out.println("Day of week: " + dayOfWeek);

        // Display the specific date
        System.out.println("\nSpecific date: " + specificDate);
        System.out.println("Day of week for specific date: " + specificDate.getDayOfWeek());
    }
}

Kompilieren und führen Sie das aktualisierte Programm aus:

javac DateComponents.java
java DateComponents

Die Ausgabe enthält nun Informationen über das spezifische Datum:

Current date: 2023-04-12
Day of month: 12
Month (number): 4
Month (name): APRIL
Year: 2023
Day of week: WEDNESDAY

Specific date: 2025-12-25
Day of week for specific date: THURSDAY

Sie haben nun gelernt, wie man Komponenten von einem LocalDate-Objekt extrahiert und Daten für bestimmte Tage erstellt. Diese Fähigkeiten sind besonders nützlich, wenn Sie Anwendungen erstellen, die datumsbasierte Operationen ausführen oder Datumsinformationen in verschiedenen Formaten anzeigen müssen.

Zusammenfassung

In diesem Tutorial haben Sie gelernt, wie man in Java mit Daten unter Verwendung der Klasse LocalDate aus der Java Time API arbeitet. Hier ist eine Zusammenfassung dessen, was Sie erreicht haben:

Erstellung eines Java-Programms zum Abrufen des aktuellen Datums mit LocalDate.now()
Berechnung zukünftiger Daten durch Hinzufügen von Tagen, Wochen, Monaten und Jahren zu einem Datum
Extrahieren von Komponenten aus einem Datum, wie z.B. Tag, Monat, Jahr und Wochentag
Erstellung eines spezifischen Datums mit der Methode LocalDate.of()

Diese grundlegenden Datumsoperationen bilden die Grundlage für komplexere datumsbasierte Funktionalitäten in Java-Anwendungen. Die Java Time API bietet eine umfassende Reihe von Klassen und Methoden für die Arbeit mit Daten und Zeiten, wodurch es einfacher wird, datumsbezogene Anforderungen in Ihren Anwendungen zu handhaben.

Einige gängige Anwendungen des erworbenen Wissens umfassen:

Berechnung von Fälligkeitsterminen für Aufgaben oder Zahlungen
Planung von Ereignissen und Terminen
Bestimmung des Wochentags für ein bestimmtes Datum
Verfolgung von Zeiträumen zwischen Ereignissen
Formatierung von Daten zur Anzeige in Benutzeroberflächen

Wenn Sie Ihre Java-Reise fortsetzen, können Sie erweiterte Funktionen der Java Time API erkunden, wie z.B. die Arbeit mit Zeitzonen, die Formatierung von Daten für verschiedene Regionen und die Durchführung komplexer Datumsberechnungen.

So erhalten Sie das aktuelle und nächste Datum mit LocalDate in Java

Einführung

Das Java Time API und LocalDate verstehen

Was ist das Java Time API?

Einführung in LocalDate

Abrufen des aktuellen Datums mit LocalDate

Importieren der LocalDate-Klasse

Verwendung der LocalDate.now() Methode

Kompilieren und Ausführen des Programms

Verstehen des Ausgabeformats

Berechnen des Folgedatums

Verstehen der Datumsmanipulation mit LocalDate

Kompilieren und Ausführen des aktualisierten Programms

Erkunden anderer Datumsmanipulationen

Wichtiges Konzept: Unveränderlichkeit (Immutability)

Extrahieren von Datumskomponenten

Methoden zur Extraktion von Datumskomponenten

Kompilieren und Ausführen des Programms

Erstellen eines spezifischen Datums

Zusammenfassung