0Pricing
Java Academy · Lektion

StringBuilder für effiziente Verkettung

Verwenden Sie StringBuilder, um Strings innerhalb von Schleifen und bei komplexen Formatierungen effizient aufzubauen.

StringBuilder für effiziente Verkettung ist eine kostenlose Java Academy-Lektion auf CoddyKit. Dies ist Lektion 2 von 4. Du kannst die komplette Lektion unten kostenlos lesen – dann übst du sie direkt im Browser mit einem integrierten Code-Editor und einem KI-Tutor rund um die Uhr. Sie ist Teil des Java Academy-Lernpfads, und dein Fortschritt wird über Web und CoddyKit-App synchronisiert. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

StringBuilder für effiziente Verkettung

StringBuilder ist eine veränderliche Alternative zu String, mit der Text schrittweise aufgebaut werden kann. Dadurch wird die Erstellung vieler temporärer String-Objekte vermieden.

StringBuilder im Vergleich zur String-Verkettung

Beim Verketten vieler Strings (insbesondere in Schleifen) ist StringBuilder deutlich schneller, da ein interner Zeichenpuffer verändert wird, anstatt neue Objekte zu erstellen.

// Inefficient: creates a new String every iteration
String result = "";
for (int i = 0; i < 1000; i++) {
    result += i + ","; // 1000 new String objects!
}

// Efficient: StringBuilder uses a resizable char buffer
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 1000; i++) {
    sb.append(i).append(',');
}
String efficient = sb.toString(); // one final String created

StringBuilder-API

Wichtige Methoden: append, insert, delete, replace, reverse, toString, length, charAt, setCharAt.

StringBuilder sb = new StringBuilder("Hello");

sb.append(", World");     // Hello, World
sb.insert(5, "!");        // Hello!, World
sb.delete(5, 6);           // Hello, World
sb.replace(7, 12, "Java"); // Hello, Java
sb.reverse();               // avaJ ,olleH
sb.reverse();               // Hello, Java

System.out.println(sb);         // Hello, Java
System.out.println(sb.length()); // 11
System.out.println(sb.charAt(0)); // H

Aufeinanderfolgende append-Aufrufe

Alle append-Methoden und andere Methoden, die das Objekt verändern, geben this zurück und ermöglichen dadurch eine fluide Verkettung.

StringBuilder html = new StringBuilder()
    .append("<div class=\"card\">")
    .append("<h2>").append("Product Title").append("</h2>")
    .append("<p>Price: $").append(String.format("%.2f", 29.99)).append("</p>")
    .append("<button>Add to Cart</button>")
    .append("</div>");

System.out.println(html.toString());

Anfangskapazität

Legen Sie für den StringBuilder eine erwartete Anfangskapazität fest, um eine Größenänderung des internen Arrays zu vermeiden und die Leistung bei großen Strings zu verbessern.

// Default capacity: 16 chars
StringBuilder small = new StringBuilder();

// Pre-sized: 10 items * ~50 chars each
StringBuilder report = new StringBuilder(500);

for (int i = 1; i <= 10; i++) {
    report.append(String.format("%-3d. Record %04d: processed OK%n", i, i));
}

System.out.println(report.toString().substring(0, 30));
// "  1. Record 0001: processed OK"

deleteCharAt und gezieltes Löschen

deleteCharAt entfernt ein einzelnes Zeichen. delete(start, end) entfernt einen Bereich. Beide Operationen haben wegen des Verschiebens von Array-Elementen die Komplexität O(n).

StringBuilder sb = new StringBuilder("Hello, World!");

sb.deleteCharAt(5);     // removes comma: "Hello World!"
sb.delete(5, 6);         // removes space: "HelloWorld!"

System.out.println(sb); // HelloWorld!

// Replace to fix a typo
StringBuilder typo = new StringBuilder("Helo, Java!");
typo.replace(typo.indexOf("Helo"), typo.indexOf("Helo") + 4, "Hello");
System.out.println(typo); // Hello, Java!

CSV erstellen

Ein praktisches Muster: Erstellen einer CSV-Zeile mit StringBuilder und korrekter Behandlung der Trennzeichen.

import java.util.List;

static String toCsv(List<String> values) {
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < values.size(); i++) {
        if (i > 0) sb.append(',');
        sb.append(escapeCsv(values.get(i)));
    }
    return sb.toString();
}

static String escapeCsv(String s) {
    if (s.contains(",") || s.contains("\""))
        return "\"" + s.replace("\"", "\"\"") + "\"";
    return s;
}

System.out.println(toCsv(List.of("Alice", "Smith, Jr.", "30")));
// Alice,"Smith, Jr.",30

StringJoiner für Ausgaben mit Trennzeichen

StringJoiner vereinfacht das Verbinden von Elementen mit einem Trennzeichen sowie optionalem Präfix und Suffix – eine manuelle Behandlung der Trennzeichen ist nicht erforderlich.

import java.util.StringJoiner;

StringJoiner sj = new StringJoiner(", ", "[", "]");
sj.add("Alice");
sj.add("Bob");
sj.add("Charlie");
System.out.println(sj.toString()); // [Alice, Bob, Charlie]

// Equivalent with String.join
String joined = String.join(", ", "Alice", "Bob", "Charlie");
System.out.println(joined); // Alice, Bob, Charlie

// Streams: collect with joining collector
import java.util.stream.*;
List.of("a", "b", "c").stream()
    .collect(Collectors.joining(", ", "(", ")"));
// (a, b, c)

StringBuilder im Vergleich zu StringBuffer

StringBuffer ist die threadsichere, synchronisierte Variante von StringBuilder. Aufgrund der Sperren ist sie langsamer. Verwenden Sie StringBuilder in Umgebungen mit nur einem Thread (in 99 % der Fälle).

// StringBuffer: thread-safe but slower (synchronized methods)
StringBuffer buf = new StringBuffer();
buf.append("Thread-safe");
buf.append(" but slow");

// StringBuilder: not thread-safe but faster
StringBuilder sb = new StringBuilder();
sb.append("Fast");
sb.append(" single-threaded");

// When to use StringBuffer:
// - Multiple threads write to the same buffer
// - Almost always a design smell — redesign to avoid sharing

Umkehren und Palindromprüfung

Mit der integrierten Methode reverse() von StringBuilder lässt sich elegant prüfen, ob ein String ein Palindrom ist.

static boolean isPalindrome(String s) {
    String cleaned = s.toLowerCase()
        .replaceAll("[^a-z0-9]", ""); // remove non-alphanumeric
    String reversed = new StringBuilder(cleaned).reverse().toString();
    return cleaned.equals(reversed);
}

System.out.println(isPalindrome("A man, a plan, a canal: Panama")); // true
System.out.println(isPalindrome("race a car"));                      // false
System.out.println(isPalindrome("Was it a car or a cat I saw?"));    // true

Praxisbeispiel: SQL-Abfrage-Builder

Erstellen einer dynamischen SQL-Abfrage mit StringBuilder, bei der Klauseln bedingt hinzugefügt werden.

static String buildQuery(String category, Double minPrice, Double maxPrice) {
    StringBuilder sql = new StringBuilder("SELECT * FROM products WHERE 1=1");
    if (category != null)
        sql.append(" AND category = '" + category + "'");
    if (minPrice != null)
        sql.append(" AND price >= ").append(minPrice);
    if (maxPrice != null)
        sql.append(" AND price <= ").append(maxPrice);
    sql.append(" ORDER BY name");
    return sql.toString();
}

System.out.println(buildQuery("Electronics", 50.0, null));
// SELECT * FROM products WHERE 1=1 AND category = 'Electronics' AND price >= 50.0 ORDER BY name

Kurzer Test

Warum ist die String-Verkettung mit + in Schleifen ineffizient?

Zusammenfassung: StringBuilder für effiziente Verkettung

Wichtige Erkenntnisse:

  • StringBuilder ist veränderlich – append/insert/delete verändern einen internen Puffer
  • Verwenden Sie StringBuilder in Schleifen, um die Erstellung von O(n²) String-Objekten zu vermeiden
  • Alle Methoden, die das Objekt verändern, geben this zurück und ermöglichen dadurch eine fluide Verkettung
  • Legen Sie für StringBuilder die erwartete Kapazität fest, um interne Größenänderungen zu reduzieren
  • StringJoiner und String.join sind praktisch für Ausgaben mit Trennzeichen
  • StringBuffer ist die synchronisierte (threadsichere), aber langsamere Alternative

Häufig gestellte Fragen

Ist die Lektion „StringBuilder für effiziente Verkettung“ kostenlos?

Ja — der vollständige Text von „StringBuilder für effiziente Verkettung“ ist hier im Web kostenlos zu lesen. Um sie interaktiv zu üben (integrierter Code-Editor und 24/7 KI-Tutor) und den Rest des Java Academy-Kurses freizuschalten, upgrade auf CoddyKit PRO. Der Java Academy-Kurs umfasst insgesamt 4 Lektionen.

Was lerne ich in „StringBuilder für effiziente Verkettung“?

Verwenden Sie StringBuilder, um Strings innerhalb von Schleifen und bei komplexen Formatierungen effizient aufzubauen. Du übst Java Academy mit praktischem Code, den du direkt im Browser ausführst, und ein 24/7 KI-Tutor beantwortet deine Fragen während du die Lektion bearbeitest.

Brauche ich Erfahrung, um Java Academy zu starten?

Keine Vorkenntnisse erforderlich. Java Academy auf CoddyKit ist für Anfänger bis fortgeschrittene Lernende strukturiert, sodass du hier starten oder von Anfang an beginnen und in deinem eigenen Tempo voranschreiten kannst. Dies ist Lektion 2 von 4.

Wie lange dauert die Lektion „StringBuilder für effiziente Verkettung“?

Die meisten CoddyKit-Lektionen dauern etwa 5–10 Minuten. Jede ist kompakt und interaktiv, sodass du stetig Fortschritte machst und genau dort weitermachst, wo du aufgehört hast – im Web und in der App.

Kann ich in dieser Java Academy-Lektion Code schreiben und ausführen?

Ja. Jede Java Academy-Lektion enthält einen integrierten Code-Editor, sodass du echten Code direkt in deinem Browser schreibst und ausführst und sofort KI-Feedback erhältst — ohne lokale Einrichtung erforderlich.

Alle Lektionen in diesem Kurs

  1. Unveränderlichkeit von String und der String-Pool
  2. StringBuilder für effiziente Verkettung
  3. Textblöcke und String.format
  4. Reguläre Ausdrücke mit Pattern und Matcher
← Zurück zu Java Academy