Java StringBuilder: So nutzt du die flexible Klasse
Die Klasse StringBuilder lässt sich in Java anstelle eines herkömmlichen Strings nutzen. Im Vergleich zu einem gewöhnlichen String ermöglicht sie direkte Anpassungen innerhalb der Zeichenkette. Solche Modifikationen lassen sich über verschiedene Methoden anstoßen.
Java StringBuilder als Alternative zum klassischen String
Die Klasse Strings in Java ist unveränderbar und verzichtet auf Unterklassen. Eine effiziente Ausweichmöglichkeit zur finalen Java-Klasse stellt der StringBuilder dar. Dieser erzeugt eine Zeichenfolge, die selbst nach der Erstellung noch modifizierbar bleibt. Der Java StringBuilder weist Ähnlichkeiten zum StringBuffer auf. Obwohl beide Klassen vergleichbare Aufgaben übernehmen, wird der StringBuilder – anders als die Buffer-Variante – nicht synchronisiert. Arbeitest du mit einem einzelnen Thread, ist diese Option besonders ratsam, da sie deutlich performanter arbeitet. Wir zeigen dir die Klasse und ihre Möglichkeiten im Detail.
Syntax und praktischer Nutzen
Die Syntax des StringBuilder in Java folgt stets einem festen Schema und sieht so aus:
public final class StringBuilder
extends Object
implements Serializable, CharSequenceUm die Funktionsweise und den Zweck der Klasse zu verstehen, hilft ein Blick auf die reguläre String-Klasse. Sobald du dort ein Objekt deklarierst, bleibt dieses fix. Möchtest du den Inhalt ändern, wird im Hintergrund ein neues Objekt mit dem angepassten Wert generiert und abgelegt. Das erzeugt unnötigen Datenmüll und kann die Performance bremsen. Setzt du hingegen den StringBuilder in Java für deine Zeichenfolgen ein, werden Korrekturen direkt an der bestehenden Abfolge vorgenommen, ohne einen neuen String zu generieren. Das spart Ressourcen und sorgt dafür, dass deine Anwendungen glatt laufen.
Constructors der Klasse
Die Klasse Java StringBuilder bietet vier Constructors an, um die Zeichenkette in das passende Format zu bringen. Zudem dienen sie der Initialkonfiguration. Hier sind die Constructors und ihre Funktionen:
StringBuilder(): Erzeugt einen leeren StringBuilder mit einer Standardkapazität von 16 Zeichen.StringBuilder(int capacity): Erstellt einen leeren StringBuilder, dessen Kapazität du über das Argument „capacity“ selbst festlegst.StringBuilder(CharSequence seq): Generiert einen StringBuilder mit den Zeichen der angegebenen Char-Sequenz.StringBuilder(String str): Erstellt einen StringBuilder auf Basis eines vorhandenen Strings.
Wie diese Constructors in der Praxis arbeiten, verdeutlicht ein kurzes Code-Beispiel. Hier siehst du alle vier Varianten im Einsatz:
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());
}
}Verwendest du nun den Java-Befehl System.out.println für die Textausgabe, sieht das Ergebnis so aus:
Erster Constructor = ABC
Zweiter Constructor = 5
Dritter Constructor = ABCDEFGHIJK
Vierter Constructor = ABCDEFGHIJKMethoden des StringBuilder in Java
Für die Java-Klasse StringBuilder existieren zahlreiche Methoden. Die wichtigsten Funktionen stellen wir dir hier anhand praktischer Code-Snippets vor.
append()
Mit der Methode append() fügst du einen String an einen bestehenden an. append() unterstützt dabei verschiedene Parameter. In der Anwendung sieht das so aus:
public class Main {
public static void main(String[] argv) throws Exception {
StringBuilder str = new StringBuilder("ABCDE");
str.append("FGHIJK");
System.out.println(str);
}
}Das Ergebnis der Ausgabe lautet:
ABCDEFGHIJKinsert()
Die Methode insert() nutzt du beim Java StringBuilder, um Text an einer exakt definierten Position einzuschleusen. Ein Beispiel zur Veranschaulichung:
public class Main {
public static void main(String[] argv) throws Exception {
StringBuilder str = new StringBuilder("ABCDE");
str.insert(1,"FGHIJK");
System.out.println(str);
}
}So sieht die zugehörige Ausgabe aus:
AFGHIJKBCDEFGHIJKÜber den Integer (hier die 1) bestimmst du den Index, an dem der neue String eingefügt wird.
replace()
Die Methode replace() tauscht einen kompletten String oder Teile davon aus. Den Bereich definierst du via beginIndex und endIndex. Hier das passende Beispiel dazu:
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);
}
}Deine Ausgabe verändert sich dadurch wie folgt:
AFGHIJKEreverse()
Mithilfe der Methode reverse() spiegelst du die gesamte Zeichenkette. Auch hierzu ein kurzes Beispiel:
public class Main {
public static void main(String[] argv) throws Exception {
StringBuilder str = new StringBuilder("ABCDE");
str.reverse();
System.out.println(str);
}
}Das liefert folgendes Ergebnis:
EDCBAdelete()
Nutzt du die Methode delete() beim Java StringBuilder, kannst du Teile oder den ganzen Text entfernen. Den zu löschenden Bereich grenzt du über beginIndex und endIndex ein:
public class Main {
public static void main(String[] argv) throws Exception {
StringBuilder str = new StringBuilder("ABCDE");
str.delete(1,4);
System.out.println(str);
}
}Das Resultat sieht dann so aus:
AEcapacity()
Die Methode capacity() verrät dir die aktuell verfügbare Zeichenkapazität des Java StringBuilders. Standardmäßig liegt diese bei 16. Bei einer Erweiterung greift die Logik „Aktuelle Länge * 2 + 2“. Startest du also bei 16, wird auf 32 verdoppelt und um zwei auf 34 erhöht. Hier das 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());
}
}Die Ausgabe liest sich folgendermaßen:
16
16
34ensureCapacity()
Die Methode ensureCapacity() garantiert, dass der Speicherplatz mindestens einem festgelegten Wert entspricht. Reicht der Platz nicht aus, wird die Kapazität erneut nach dem Schema „Bisherige Länge * 2 + 2“ angepasst. Das zeigt dieses 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());
}
}Damit erhältst du diese Anzeige:
16
16
34
34
70Zunächst griff zweimal der Standardwert (16), danach zweimal der verdoppelte Wert plus zwei (34) und am Ende wurde die Kapazität nochmals auf 70 (34 * 2 + 2) hochgeschraubt.