Java Academy · Lektion

Strings mit StringBuilder erstellen

Effiziente Verkettung

Strings mit StringBuilder erstellen 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.

Ein veränderlicher StringBuilder

StringBuilder ist eine veränderliche Zeichenfolge. Anders als bei String können Sie ihren Inhalt direkt verändern, wodurch das Erstellen von Text effizient wird.

Einen StringBuilder erstellen

Erstellen Sie mit new StringBuilder() einen leeren Builder oder übergeben Sie einen Ausgangstext, mit dem der Builder beginnen soll.

public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        StringBuilder named = new StringBuilder("Hello");
        System.out.println("empty length: " + sb.length());
        System.out.println("named: " + named);
    }
}

Text anhängen

Die Methode append fügt Inhalte am Ende hinzu. Sie akzeptiert Strings, Zahlen, Zeichen, boolesche Werte und vieles mehr.

public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        sb.append("Count: ");
        sb.append(5);
        sb.append(' ');
        sb.append(true);
        System.out.println(sb);
    }
}

Methodenverkettung

append gibt denselben Builder zurück, sodass Sie Aufrufe flüssig in einem Ausdruck verketten können.

public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        sb.append("a").append("b").append("c").append(123);
        System.out.println(sb);
    }
}

In einer Schleife erstellen

Das ist der wichtigste Anwendungsfall. Hängen Sie innerhalb einer Schleife Inhalte an, ohne jedes Mal ein neues Objekt zu erstellen, und wandeln Sie den Builder am Ende einmal um.

public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        for (int i = 1; i <= 10; i++) {
            sb.append(i).append(' ');
        }
        System.out.println(sb.toString().trim());
    }
}

In einen String umwandeln

Rufen Sie toString() auf, um einen gewöhnlichen unveränderlichen String aus dem Builder zu erhalten, sobald Sie mit den Änderungen fertig sind.

public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("result");
        String finalText = sb.toString();
        System.out.println(finalText.toUpperCase());
    }
}

Mit einem Trennzeichen verbinden

Sie können durch Anhängen eines Trennzeichens zwischen den Elementen durch Kommas getrennte Listen erstellen. Achten Sie dabei auf das letzte Element.

public class Main {
    public static void main(String[] args) {
        String[] names = {"Ann", "Ben", "Cara"};
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < names.length; i++) {
            sb.append(names[i]);
            if (i < names.length - 1) {
                sb.append(", ");
            }
        }
        System.out.println(sb);
    }
}

Die Länge lesen

length() gibt an, wie viele Zeichen der Builder momentan enthält. Der Wert wird beim Anhängen aktualisiert.

public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder();
        sb.append("12345");
        System.out.println("Length: " + sb.length());
    }
}

Auf Zeichen zugreifen

Verwenden Sie charAt(index), um wie bei einem String ein einzelnes Zeichen anhand seiner Position zu lesen.

public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder("Coddy");
        System.out.println("First: " + sb.charAt(0));
        System.out.println("Last: " + sb.charAt(sb.length() - 1));
    }
}

Kapazität und Länge

Ein Builder verwaltet einen internen Puffer (die Kapazität), der automatisch wächst. Sie können eine Anfangskapazität übergeben, um bei bekannter endgültiger Größe eine Größenänderung zu vermeiden.

public class Main {
    public static void main(String[] args) {
        StringBuilder sb = new StringBuilder(100);
        sb.append("short");
        System.out.println("Length: " + sb.length());
        System.out.println("Capacity at least: " + (sb.capacity() >= 100));
    }
}

Ein praktischer Builder

Alles zusammen: Erstellen Sie mithilfe verketteter append-Aufrufe und einer Schleife effizient einen kleinen Berichtstext.

public class Main {
    public static void main(String[] args) {
        int[] sales = {100, 250, 75};
        StringBuilder report = new StringBuilder("Sales Report\n");
        int total = 0;
        for (int i = 0; i < sales.length; i++) {
            report.append("Day ").append(i + 1).append(": ").append(sales[i]).append('\n');
            total += sales[i];
        }
        report.append("Total: ").append(total);
        System.out.println(report);
    }
}

Kurzer Test

Warum ist StringBuilder effizienter als wiederholte Konkatenation mit + in einer Schleife?

Zusammenfassung

Sie haben gelernt, mit StringBuilder Strings zu erstellen:

Er ist eine veränderliche Zeichenfolge
append fügt Inhalte hinzu und unterstützt die Methodenverkettung
Ideal zum Erstellen von Text in Schleifen
Rufen Sie toString() auf, um den endgültigen String zu erhalten
Eine Anfangskapazität vermeidet Größenänderungen

Häufig gestellte Fragen

Ist die Lektion „Strings mit StringBuilder erstellen“ kostenlos?

Ja — der vollständige Text von „Strings mit StringBuilder erstellen“ 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 „Strings mit StringBuilder erstellen“?

Effiziente Verkettung 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 „Strings mit StringBuilder erstellen“?

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

← Zurück zu Java Academy