Java String-Methoden

Die Klasse String enthält Dutzende von Methoden. Dieses Kapitel ist eine praktische Referenz der am häufigsten verwendeten Methoden, gruppiert nach ihrer Funktion: Untersuchen, Vergleichen, Suchen, Zerlegen, Transformieren, Teilen/Verbinden, Konvertieren und Formatieren.

Wichtig: Strings sind unveränderlich (immutable). Jede der folgenden Methoden gibt einen neuen String (oder einen anderen Wert) zurück — sie ändert den String nicht, auf dem sie aufgerufen wurde. Das bedeutet, ein Aufruf wie s.toUpperCase(); allein bewirkt nichts Nützliches; du musst das Ergebnis speichern:

String s = "hello";
s.toUpperCase();        // result discarded — s is still "hello"
s = s.toUpperCase();    // s is now "HELLO"

Indizes sind nullbasiert und zählen UTF-16-Code-Einheiten, nicht benutzerseitig wahrgenommene Zeichen — das ist relevant für Emojis und andere ergänzende Zeichen.

Einen String untersuchen

"hello".length();      // 5
"".isEmpty();          // true
"   ".isBlank();       // true
"hello".charAt(1);     // 'e'

Strings vergleichen

"hi".equals("hi");                  // true
"HI".equalsIgnoreCase("hi");        // true
"apple".compareTo("banana");        // negative

Für den Inhaltsvergleich solltest du stets .equals() statt == verwenden (Vergleichsoperatoren). == vergleicht Objekt-Referenzen — ob zwei Variablen auf dasselbe Objekt zeigen — nicht die enthaltenen Zeichen. Da Java String-Literale intern hält (internt), scheint == manchmal zu funktionieren, schlägt aber fehl, sobald ein String zur Laufzeit erstellt wird:

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

a == b;          // true  — both point to the same interned literal
a == c;          // false — c is a different object
a.equals(c);     // true  — same contents

compareTo eignet sich zum Sortieren: Es gibt eine negative Zahl, null oder eine positive Zahl zurück und lässt sich direkt in Collections.sort oder Comparator-Ketten einsetzen.

Suchen

String s = "abc-xyz-abc";
s.contains("xyz");       // true
s.indexOf("abc");        // 0
s.lastIndexOf("abc");    // 8
s.startsWith("abc");     // true
s.endsWith("xyz");       // false

Zerlegen (Slicing)

String s = "Hello, World!";
s.substring(7);        // "World!"
s.substring(7, 12);    // "World"

Negative Indizes sind nicht erlaubt — sie werfen eine StringIndexOutOfBoundsException.

Transformieren

"  hello  ".strip();                 // "hello"
"banana".replace("a", "_");          // "b_n_n_"
"hello".repeat(3);                   // "hellohellohello"
"abc 123".replaceAll("\\d", "*");    // "abc ***"

Teilen und Verbinden

"a,b,c".split(",");                     // ["a","b","c"]
String.join("-", "a", "b", "c");        // "a-b-c"
String.join(",", List.of("a","b"));     // "a,b"
"line1\nline2\nline3".lines().count();  // 3

split erwartet einen Regex, keinen einfachen String — daher müssen Regex-Metazeichen maskiert werden: Verwende split("\\.") zum Aufteilen an einem wörtlichen Punkt, nicht split(".") (das jedes Zeichen trifft und ein leeres Array zurückgibt). Abschließende leere Strings werden standardmäßig weggelassen; übergib ein negatives limit (z. B. split(",", -1)), um sie beizubehalten.

Konvertierung

String.valueOf(42);              // "42"
Integer.parseInt("42");          // 42
Double.parseDouble("3.14");      // 3.14
"hello".toCharArray();           // {'h','e','l','l','o'}

Die parse*-Methoden werfen eine NumberFormatException, wenn der Text keine gültige Zahl ist — umschließe Benutzereingaben daher mit try/catch oder validiere sie vorher. Anders als parseInt ist String.valueOf(null) sicher — es gibt den String "null" zurück, anstatt eine Ausnahme zu werfen.

Formatierung

String.format("%s is %d", "Ada", 36);     // "Ada is 36"
"%s is %d".formatted("Ada", 36);          // "Ada is 36"

Eine kombinierte Demonstration

Was kommt als nächstes

Java String-Verkettung erläutert +, concat und StringBuilder im Detail — einschließlich der Frage, wann welches Mittel das richtige ist.

Übungen