Zeit, Weiteres zu Strings

1. Datum, Tageszeit und Zeitpunkt

in Arbeit ...

Traditionell war für die Handhabung von Datum und Zeit die Klasse java.util.Date zuständig (Details siehe z.B. Oracle : Java SE 8 Date and Time), wurde später mit Klassen wie java.util.GregorianCalendar ergänzt (siehe ).z.B. GregorianCalendar (Java Platform SE 7 ) Diese Klassen waren nie optimal für Zeitliches. Daher wurde mit Java-8 ein neues, recht umfassend und modern konzipiertes Zeit-Framework eingeführt, das wir nun näher ansehen werden.

Als Basis-Package wird verwendet: java.time. Direkt darin und in Subpackages finden sich alle dazugehörigen Klassen.

Wir beschränken uns hier auf die Basics:

  • Datum/Zeit-Objekt erzeugen mit Zahlenwerten f. Jahr, Monat, Tag, Stunde, Minute, Sekunde

  • Datum-/Zeit-Objekt erzeugen aus String (z.B. "2021-06-14" oder "18:59" oder "2007-12-03T10:15:30").
    Für genauere Kontrolle des im String verwendeten Formats kann Klasse java.time.format.DateTimeFormatter verwendet werden. Darauf wird hier allerdings nicht näher eingegangen.

  • Datum-/Zeit-Objekt erzeugen mit aktuellen Werten

  • Datum-/Zeit-Komponenten (Wochentag, Jahr, Zeitzone, …​)

  • Zugriff auf einzelne Komponenten mittels Gettern

  • Formatierte, selektive Ausgabe der Zeitinformation (oder Teilen wie Wochentag, Jahr, etc.) mit DateTimeFormatter

  • Formatierte, selektive Ausgabe der Zeitinformation (oder Teilen wie Wochentag, Jahr, etc.) mit String.format(…​) u.ä.

    und auf die Klassen `java.time.LocalDate`, `java.time.LocalTime`, `java.time.LocalDateTime`

Auch Zeitvergleiche, Differenzberechnungen, Addieren von Zeitspannen etc. werden nur minimal erwähnt und nicht weiter behandelt. Ein Blick auf die API-Dokumentation – z.B. unter LocalDateTime (Java SE 16 & JDK 16) liefert hier rasch guten Einblick.

public class DemoLocalDateAndFormat {
    public void localDateDemo() {
            LocalDate now = LocalDate.now();  // aktueller Tag
            LocalDate someDate = LocalDate.of(2002, 02, 22);  // mit 3 Zahlen
            System.out.format("Jahre zwischen %TF und %TF: %d%n", //T..time-prefix, F..Full ISO Date
                    now, someDate, (now.getYear() - someDate.getYear()));
            System.out.println("Heute ist %TF".formatted(LocalDate.now()));

            LocalDate date1 = LocalDate.parse("1999-09-22");  // als String
            // weitere Ausgabe- und Parse-Konfigurationsmöglichkkeit (selber Formatter!)
            DateTimeFormatter myFormatter = DateTimeFormatter.ofPattern("d. M. yyyy");
            System.out.format("als 'date1' gegeben: %s%n", date1.format(myFormatter));

            LocalDate date2 = LocalDate.parse("20. 11. 2011", myFormatter);
            System.out.format("als 'date2' gegeben: %s%n", date1.format(DateTimeFormatter.ISO_DATE));
    }
}

Ausgegeben wird damit:

Jahre zwischen 2022-06-01 und 2002-02-22: 20
Heute ist 2022-06-01
als 'date1' gegeben: 22. 9. 1999
als 'date2' gegeben: 2011-11-20
in Arbeit ...

2. String-Methoden und Verwandtes

Hier werden 3 sehr wichtige String-Methoden vorgestellt bzw. wiederholt:

  • String[] split(String sepRegex)

  • static String format("Format-String mit Ersetzungszeichen String: %s", Ganzzahl: %d, Boolean: %b, Char: %c, "txt", 3, true, 'x' ) in Arbeit …​

2.1. Formatieren von Texten

    public void formatDemo() {
        // https://docs.oracle.com/en/java/javase/17/docs/api/java.base/java/util/Formatter.html
        String s = String.format("String:\"%s\", Ganzzahl:%d, Nichtganzzahl:%f (formatiert: %06.3f), Char:'%c', Boolean:%B",
                "Hallo", -999, 3.1415926, Math.sqrt(2), 'x', true);
        System.out.println(s);   // liefert:
        // String:"Hallo", Ganzzahl:-999, Nichtganzzahl:3,141593 (formatiert: 01,414), Char:'x', Boolean:TRUE
    }
split, format, formatted, System.out.format

2.2. Aufsplitten von Text mittels Split-Mustern

in Arbeit ...

3. Effiziente Erzeugung komplexer Strings

in Arbeit ...

Klasse java.lang.StringBuilder ist die üblicherweise zum Zusammenbauen komplexer Strings genutzte Klasse. Sie ist großteils analog zu Klasse java.lang.StringBuffer zu nutzen, nur ist StringBuilder nicht automatisch für Parallelverarbeitung (Multi-Threading) gerüstet und damit deutlich "schneller".

Zum Verständnis: Java Strings sind immutable, d.h. ein String kann nachträglich nicht geändert werden. Stattdessen wird immer ein neues String-Objekt erzeugt, wenn "Änderungen" stattfinden:

    public void demoImmutableString() {
        String a = "Hallo";  // ein String-Objekt
        String b = a;       // zweite Referenz auf "Hallo"
        a += " ihr da!";   // neues String-Obj. wird der selben
                           //     Objektreferenz zugewiesen
        // a zeigt nun auf "Hallo ihr da!", alter String ginge verloren,
        //.. wenn nicht noch immer die 2. Referenz b darauf zeigen würde.
    }

Das ist bei vielstufiger Zusammensetzung aufwändig, da bei jedem '+' ein neues Objekt erzeugt und bei weiterem Hinzufügen wieder verworfen wird.

Hier hilft Klasse StringBuilder, da sie im Gegensatz zu String änderbare Objekte bereitstellt, die am Schluss, wenn alles fertig ist, ein einziges Mal mit Methode toString() ein neues String-Objekt erzeugen lassen.

Hier ein Anwendungsbeispiel:

== Scribble
LocalDate, LocalTime, LocalDateTime
instanceof