Java Strings

Ein String repräsentiert eine Zeichenfolge und ist nach int der Typ, den du am häufigsten verwenden wirst. Es handelt sich um eine Klasse (kein primitiver Typ), aber Java bietet eine spezielle Syntax — Literale in doppelten Anführungszeichen und den Operator + für die Verkettung — sodass sich die Verwendung wie bei einem primitiven Typ anfühlt. Das Wichtigste über Strings: Sie sind unveränderlich (immutable).

Dieses Kapitel behandelt, wie man Strings erstellt, warum Unveränderlichkeit wichtig ist, wie man ihre Länge misst und auf einzelne Zeichen zugreift, wie man sie korrekt vergleicht, die gängigen Methoden, Verkettung, mehrzeilige Textblöcke und Formatierung.

Einen String erstellen

Der einfachste Weg ist ein String-Literal in doppelten Anführungszeichen:

String greeting = "Hello, World!";
String empty = "";
String multi = "Line 1\nLine 2";   // \n is a newline

Du kannst auch einen mit new erstellen, obwohl es selten einen Grund dafür gibt:

String fromLiteral = "Hello";
String fromNew = new String("Hello");

new String(...) erstellt immer ein neues Objekt. Literale werden gepoolgt — zwei Literale mit denselben Zeichen sind dasselbe Objekt. Das ist bei ==-Vergleichen relevant, aber sonst kaum; du solltest stets .equals() verwenden, um Inhalte zu vergleichen.

Strings sind unveränderlich

Sobald ein String erstellt wurde, ändert sich sein Inhalt nie. Jede Methode, die einen String „ändert", gibt tatsächlich einen neuen String zurück:

String s = "hello";
s.toUpperCase();
System.out.println(s);   // "hello" — unchanged

s = s.toUpperCase();
System.out.println(s);   // "HELLO" — new string assigned

Unveränderlichkeit hat mehrere Vorteile:

• Sicher für den Einsatz in mehreren Threads — keine Synchronisierung erforderlich.
• Hash-Code kann zwischengespeichert werden.
• Strings können sicher als Map-Schlüssel verwendet werden.

Der Nachteil: Einen langen String in einer Schleife mit + aufzubauen, erzeugt viele Zwischenstrings. Verwende dafür StringBuilder (String Concatenation).

Länge und Indizierung

length() gibt die Anzahl der Zeichen zurück:

String s = "hello";
System.out.println(s.length());   // 5

charAt(i) gibt das Zeichen am Index i zurück (nullbasiert):

System.out.println(s.charAt(0));   // 'h'
System.out.println(s.charAt(4));   // 'o'
// s.charAt(5);  // StringIndexOutOfBoundsException

Hinweis: length() ist die Anzahl der UTF-16-Codeeinheiten, nicht immer die Anzahl der vom Benutzer wahrgenommenen Zeichen. Für die meisten ASCII- und BMP-Texte sind sie identisch, aber Emojis und einige nicht-lateinische Schriften verwenden Surrogatpaare und zählen als 2.

Strings vergleichen

Verwende .equals() für den Inhaltsvergleich, niemals ==:

String a = new String("hi");
String b = new String("hi");

System.out.println(a == b);         // false
System.out.println(a.equals(b));    // true

equalsIgnoreCase ignoriert die Groß-/Kleinschreibung:

"HELLO".equalsIgnoreCase("hello");  // true

Für die Sortierung verwende compareTo. Die Methode vergleicht Strings lexikografisch (nach Zeichencode) und gibt eine negative Zahl zurück, wenn der erste String vor dem zweiten einsortiert wird, 0 wenn sie gleich sind, und eine positive Zahl, wenn er danach kommt:

"apple".compareTo("banana");        // negative (a < b)
"apple".compareTo("apple");         // 0  — equal
"banana".compareTo("apple");        // positive (b > a)

Da der Vergleich nach Zeichencode erfolgt, werden Großbuchstaben (A–Z, Codes 65–90) vor Kleinbuchstaben (a–z, Codes 97–122) einsortiert. Verwende compareToIgnoreCase für eine Sortierung ohne Berücksichtigung der Groß-/Kleinschreibung.

Häufige Operationen

Die am häufigsten verwendeten Methoden mit Beispielen:

String s = "  Hello, World!  ";

s.length();                  // 17
s.trim();                    // "Hello, World!" (whitespace removed)
s.strip();                   // "Hello, World!" (Unicode-aware, Java 11+)
s.toUpperCase();             // "  HELLO, WORLD!  "
s.toLowerCase();             // "  hello, world!  "
s.contains("World");         // true
s.startsWith("  Hello");     // true
s.endsWith("!  ");           // true
s.indexOf("World");          // 9
s.indexOf("xyz");            // -1
s.replace(",", ";");         // "  Hello; World!  "
s.substring(2, 7);           // "Hello"
s.split(", ");               // ["  Hello", "World!  "]
s.isEmpty();                 // false  — length() == 0?
s.isBlank();                 // false  — only whitespace? (Java 11+)

Die vollständige Referenz findest du unter Java String Methods.

Verkettung

Der Operator + verbindet Strings und konvertiert bei Bedarf andere Typen in Strings:

String name = "Ada";
int age = 36;
String msg = "Name: " + name + ", Age: " + age;
// "Name: Ada, Age: 36"

Innerhalb einer Schleife ist StringBuilder vorzuziehen:

StringBuilder sb = new StringBuilder();
for (int i = 0; i < 10; i++) {
    sb.append(i).append(",");
}
String result = sb.toString();

Textblöcke — mehrzeilige Strings

Seit Java 15 ermöglichen Textblöcke das Schreiben mehrzeiliger Strings ohne Escape-Sequenzen:

String json = """
        {
          "name": "Ada",
          "age": 36
        }
        """;

Der Compiler entfernt den gemeinsamen führenden Leerraum aus jeder Zeile, sodass die Einrückung im Quellcode nicht in den String übernommen wird.

Formatierung

String.format erstellt einen String mit printf-ähnlichen Platzhaltern:

String s = String.format("Name: %s, Age: %d", "Ada", 36);

Die Platzhalter sind dieselben wie bei System.out.printf — siehe Java Output.

Eine Demonstration

Was kommt als nächstes

Java String Methods — eine Referenz aller Methoden, die du regelmäßig verwenden wirst.

Übungen