Java String-Verkettung

„Verkettung" bedeutet einfach, Strings hintereinander zu hängen. Java bietet dafür mehrere Möglichkeiten — +, concat, String.format, Textblöcke, StringBuilder, String.join. Sie unterscheiden sich in Lesbarkeit und, bei Schleifen, in der Leistung.

Der +-Operator

+ ist der alltägliche Weg:

String first = "Ada";
String last = "Lovelace";
String full = first + " " + last;     // "Ada Lovelace"

Er konvertiert auch Nicht-Strings über deren toString() in Strings:

int age = 36;
String s = "Age: " + age;             // "Age: 36"

Hinter den Kulissen wandelt der Compiler a + b + c in ein einziges StringBuilder.append(...).append(...).toString() um. Ein verketteter +-Ausdruck ist also effizient.

concat

String.concat(other) gibt diesen String gefolgt von other zurück:

"Hello, ".concat("World!");    // "Hello, World!"

Dies ist im Wesentlichen dasselbe wie +, akzeptiert aber nur einen String (keine automatische Konvertierung). Die meisten Programme verwenden einfach +.

String.format und formatted

Für die Verkettung mehrerer Teile mit typspezifischer Formatierung ist String.format übersichtlicher als lange +-Ketten:

String name = "Ada";
int age = 36;
String s = String.format("%s is %d years old", name, age);

Seit Java 15 ist die Instanzmethode formatted gleichwertig und liest sich von links nach rechts:

"%s is %d years old".formatted(name, age);

Textblöcke für mehrzeilige Strings

Für mehrzeilige Strings vermeidet die Textblock-Syntax (Java 15+) lange \n-Ketten:

String json = """
        {
          "name": "%s",
          "age": %d
        }
        """.formatted(name, age);

StringBuilder — für Schleifen

Java-Strings sind unveränderlich — einmal erstellt, kann ein String nie verändert werden. Jedes + auf einem String erzeugt daher ein brandneues Objekt. In einer Schleife mit Tausenden von Iterationen bedeutet das viel kurzlebigen Müll und Kopiervorgänge. Verwenden Sie stattdessen StringBuilder — er verfügt über einen einzigen veränderlichen internen Puffer, der an Ort und Stelle wächst:

StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1000; i++) {
    sb.append("line ").append(i).append("\n");
}
String result = sb.toString();

Die StringBuilder-Methoden, die Sie verwenden werden:

• append(any) — an das Ende anfügen (gibt den Builder zurück, sodass Sie verketten können).
• insert(index, any) — an einer Position einfügen.
• delete(start, end) — einen Bereich entfernen.
• reverse() — den Inhalt des Builders umkehren.
• length() und setLength(n) — lesen / kürzen.
• toString() — den endgültigen String erzeugen.

Es gibt auch StringBuffer, das identisch, aber thread-sicher ist (jede Methode ist synchronized). Sie brauchen es fast nie — verwenden Sie StringBuilder, es sei denn, Sie teilen den Builder tatsächlich zwischen Threads.

String.join — für Kollektionen

Wenn Sie eine Kollektion von Strings und einen Trenner haben, ist String.join am saubersten:

String csv = String.join(",", "a", "b", "c");        // "a,b,c"
String csv2 = String.join(", ", List.of("a", "b", "c"));   // "a, b, c"

Für fortgeschritteneres Verbinden (Collectors, bedingte Aufnahme) lesen Sie später im Buch über Collectors.joining in Streams.

Wann was verwenden

Ein grober Entscheidungsbaum:

• Ein oder zwei Teile, von links nach rechts lesbar → +.
• Mehrere Teile mit Typformatierung → String.format oder formatted.
• Mehrzeiliges Literal → Textblock, optional mit .formatted.
• Stückweise in einer Schleife aufbauen → StringBuilder.
• Kollektion mit Trenner verbinden → String.join.

Bei kleinen Verkettungen machen moderne Compiler und die JVM (mit der auf invokedynamic basierenden String-Verkettung, die in Java 9 eingeführt wurde) + sehr schnell — die Leistung ist kein Grund, es für einfache Fälle zu vermeiden.

Eine Demonstration des Schleifenfalls

Was kommt als Nächstes

Java-Sonderzeichen und Escape-Sequenzen — was \n, \t, \" und die Unicode-Escapes bewirken.

Übungen