Java StringBuilder: So funktioniert die veränderbare Klasse

Die Klasse StringBuilder kann in Java statt eines herkömmlichen Strings verwendet werden. Im Gegensatz zu einem String erlaubt sie direkte Veränderungen innerhalb der Zeichenfolge. Diese Änderungen können durch unterschiedliche Methoden initiiert werden.

Java StringBuilder als Alternative zum herkömmlichen String

Die Klasse Strings in Java ist unveränderlich und kommt ohne Unterklassen aus. Eine Alternative zu der finalen Klasse in Java ist StringBuilder. Diese erzeugt eine Abfolge von Zeichen, die auch nach der Erstellung noch veränderbar ist. Java StringBuilder ähnelt damit StringBuffer. Beide Klassen erfüllen zwar eine ähnliche Aufgabe, im Gegensatz zur Buffer-Option wird StringBuilder allerdings nicht synchronisiert. Für die Arbeit mit einem einzelnen Thread ist diese Wahl daher besonders empfehlenswert, da sie deutlich schneller als die Alternative arbeiten kann. Wir zeigen Ihnen die Klasse und ihre Möglichkeiten.

Syntax und Nutzen

Die Syntax von StringBuilder in Java folgt immer demselben Muster und sieht folgendermaßen aus:

public final class StringBuilder
	extends Object
		implements Serializable, CharSequence

Um zu verstehen, wie die Klasse grundsätzlich funktioniert und welchen Zweck sie erfüllt, lohnt zunächst ein Blick auf die reguläre Klasse String. Wenn Sie in String ein Objekt deklarieren, ist dieses danach nicht mehr veränderbar. Möchten Sie nun Änderungen durchführen, wird ein neues Objekt mit dem veränderten Wert erstellt und gespeichert. Das sorgt für Datenmüll und kann auch zu einer schwächeren Performance führen. Nutzen Sie nun stattdessen StringBuilder in Java für eine Abfolge von Zeichen, werden Änderungen an ebendieser Abfolge vorgenommen und dabei kein neuer String erstellt. Das reduziert den Müll und verbessert die Performance.

Constructors der Klasse

Die Klasse Java StringBuilder verfügt über vier Constructors, die dabei helfen, die Zeichenfolge in das passende Format für die Klasse zu bringen. Außerdem dienen sie zur Konfiguration. Dies sind die Constructors und ihre Aufgaben:

• StringBuilder(): Generiert einen leeren StringBuilder mit einer maximalen Kapazität von 16 Zeichen.
• StringBuilder(int capacity): Erstellt einen StringBuilder ohne Zeichen, dessen maximale Zeichenanzahl mit Hilfe des Arguments „capacity“ festgelegt wird.
• StringBuilder(CharSequence seq): Generiert einen StringBuilder mit denselben Zeichen wie die hinterlegte Char-Sequenz.
• StringBuilder(String str): Erstellt einen StringBuilder auf Basis des hinterlegten Strings.

Die Funktionsweise der Constructors in der Praxis lässt sich am besten direkt mit einem Code-Beispiel veranschaulichen. So funktionieren alle vier Optionen:

public class Main {
	public static void main(String[] argv) throws Exception {
	StringBuilder str = new StringBuilder();
	str.append("ABC");
	System.out.println("Erster Constructor = " + str.toString());
	StringBuilder str2 = new StringBuilder(5);
	System.out.println("Zweiter Constructor = " + str2.capacity());
	StringBuilder str3 = new StringBuilder("ABCDEFGHIJK");
	System.out.println("Dritter Constructor = " + str3.toString());
	StringBuilder str4 = new StringBuilder(str3.toString());
	System.out.println("Vierter Constructor = " + str4.toString());
	}
}

Wenn Sie nun den Java-Befehl System.out.println für die Ausgabe nutzen, erhalten Sie dies:

Erster Constructor = ABC
Zweiter Constructor = 5
Dritter Constructor = ABCDEFGHIJK
Vierter Constructor = ABCDEFGHIJK

Beispiele für Methoden von StringBuilder in Java

Es gibt zahlreiche Methoden für die Java-Klasse StringBuilder. Einige der wichtigsten stellen wir Ihnen hier mit den passenden Codeausschnitten vor.

append()

Die Methode append() wird genutzt, um einen String zu einem anderen hinzuzufügen. append() hat unterschiedliche Parameter. In der Praxis funktioniert die Methode wie im folgenden Beispiel:

public class Main {
	public static void main(String[] argv) throws Exception {
	StringBuilder str = new StringBuilder("ABCDE");
	str.append("FGHIJK");
	System.out.println(str);
	}
}

Als Ausgabe erhalten Sie dies:

ABCDEFGHIJK

insert()

Die Methode insert() wird in Kombination mit dem Java StringBuilder genutzt, um einen String an einer bestimmten Stelle einzufügen. So sieht das beispielhaft aus:

public class Main {
	public static void main(String[] argv) throws Exception {
	StringBuilder str = new StringBuilder("ABCDE");
	str.insert(1,"FGHIJK");
	System.out.println(str);
	}
}

Dies ist die passende Ausgabe:

AFGHIJKBCDEFGHIJK

Mit dem Integer (in diesem Fall 1) legen Sie fest, an welcher Stelle der String eingesetzt werden soll.

replace()

Die Methode replace() ersetzt einen String oder den Teil eines Strings. Dieser wird durch beginIndex und endIndex definiert. Dies ist das passende Beispiel:

public class Main {
	public static void main(String[] argv) throws Exception {
	StringBuilder str = new StringBuilder("ABCDE");
	str.replace(1,4,"FGHIJK");
	System.out.println(str);
	}
}

Nun sieht Ihre Ausgabe folgendermaßen aus:

AFGHIJKE

reverse()

Mit der Methode reverse() drehen Sie den hinterlegten String komplett um. Auch dies veranschaulichen wir mit einem passenden Beispiel:

public class Main {
	public static void main(String[] argv) throws Exception {
	StringBuilder str = new StringBuilder("ABCDE");
	str.reverse();
	System.out.println(str);
	}
}

Dies ergibt die folgende Ausgabe:

EDCBA

delete()

Wenn Sie die Methode delete() mit StringBuilder in Java verwenden, können Sie den gesamten String oder einen Teil löschen. Diesen Teil definieren Sie ebenfalls über beginIndex und endIndex. Dies haben wir auch in unserem Beispiel getan:

public class Main {
	public static void main(String[] argv) throws Exception {
	StringBuilder str = new StringBuilder("ABCDE");
	str.delete(1,4);
	System.out.println(str);
	}
}

Nun erhalten Sie diese Ausgabe:

AE

capacity()

Die Methode capacity() gibt Ihnen die aktuelle maximale Zeichenanzahl des Java StringBuilders aus. Diese liegt normalerweise bei 16. Wird sie erhöht, passiert dies nach der Formel „Bisherige Zeichenlänge * 2 + 2“. Lag sie bisher also bei 16, wird sie nun verdoppelt (32) und um zwei erweitert (34). Hier sehen Sie das passende Beispiel:

public class Main {
	public static void main(String[] argv) throws Exception {
	StringBuilder str = new StringBuilder();
System.out.println(str.capacity());
str.append("ABCDE");
System.out.println(str.capacity());
	str.append("Dies ist ein anderes Beispiel");
	System.out.println(str.capacity());
	}
}

Ihre Ausgabe liest sich nun so:

16
16
34

ensureCapacity()

Die Methode ensureCapacity() stellt sicher, dass die verfügbare Zeichenanzahl mindestens einem definierten Wert entspricht. Ist dies nicht der Fall, wird die Kapazität wieder nach der Formel „Bisherige Zeichenlänge * 2 + 2“ erweitert. Das sehen Sie an diesem Beispiel:

public class Main {
	public static void main(String[] argv) throws Exception {
	StringBuilder str = new StringBuilder();
System.out.println(str.capacity());
str.append("ABCDE");
System.out.println(str.capacity());
	str.append("Dies ist ein anderes Beispiel");
	System.out.println(str.capacity());
	str.ensureCapacity(5);
	System.out.println(str.capacity());
	str.ensureCapacity(40);
	System.out.println(str.capacity());
	}
}

Dadurch erhalten Sie diese Ausgabe:

16
16
34
34
70

Zuerst wurde zweimal der Standardwert (16) berücksichtigt, dann zweimal der doppelte Wert plus zwei (34) und zuletzt der Wert noch einmal verdoppelt und um zwei ergänzt (70).