Java String­Buil­der: So funk­tio­niert die ver­än­der­ba­re Klasse

Die Klasse String­Buil­der kann in Java statt eines her­kömm­li­chen Strings verwendet werden. Im Gegensatz zu einem String erlaubt sie direkte Ver­än­de­run­gen innerhalb der Zei­chen­fol­ge. Diese Än­de­run­gen können durch un­ter­schied­li­che Methoden initiiert werden.

Java String­Buil­der als Al­ter­na­ti­ve zum her­kömm­li­chen String

Die Klasse Strings in Java ist un­ver­än­der­lich und kommt ohne Un­ter­klas­sen aus. Eine Al­ter­na­ti­ve zu der finalen Klasse in Java ist String­Buil­der. Diese erzeugt eine Abfolge von Zeichen, die auch nach der Er­stel­lung noch ver­än­der­bar ist. Java String­Buil­der ähnelt damit String­Buf­fer. Beide Klassen erfüllen zwar eine ähnliche Aufgabe, im Gegensatz zur Buffer-Option wird String­Buil­der al­ler­dings nicht syn­chro­ni­siert. Für die Arbeit mit einem einzelnen Thread ist diese Wahl daher besonders emp­feh­lens­wert, da sie deutlich schneller als die Al­ter­na­ti­ve arbeiten kann. Wir zeigen Ihnen die Klasse und ihre Mög­lich­kei­ten.

Syntax und Nutzen

Die Syntax von String­Buil­der in Java folgt immer demselben Muster und sieht fol­gen­der­ma­ßen aus:

public final class StringBuilder
	extends Object
		implements Serializable, CharSequence

Um zu verstehen, wie die Klasse grund­sätz­lich funk­tio­niert und welchen Zweck sie erfüllt, lohnt zunächst ein Blick auf die reguläre Klasse String. Wenn Sie in String ein Objekt de­kla­rie­ren, ist dieses danach nicht mehr ver­än­der­bar. Möchten Sie nun Än­de­run­gen durch­füh­ren, wird ein neues Objekt mit dem ver­än­der­ten Wert erstellt und ge­spei­chert. Das sorgt für Datenmüll und kann auch zu einer schwä­che­ren Per­for­mance führen. Nutzen Sie nun statt­des­sen String­Buil­der in Java für eine Abfolge von Zeichen, werden Än­de­run­gen an eben­die­ser Abfolge vor­ge­nom­men und dabei kein neuer String erstellt. Das reduziert den Müll und ver­bes­sert die Per­for­mance.

Con­s­truc­tors der Klasse

Die Klasse Java String­Buil­der verfügt über vier Con­s­truc­tors, die dabei helfen, die Zei­chen­fol­ge in das passende Format für die Klasse zu bringen. Außerdem dienen sie zur Kon­fi­gu­ra­ti­on. Dies sind die Con­s­truc­tors und ihre Aufgaben:

• StringBuilder(): Generiert einen leeren String­Buil­der mit einer maximalen Kapazität von 16 Zeichen.
• StringBuilder(int capacity): Erstellt einen String­Buil­der ohne Zeichen, dessen maximale Zei­chen­an­zahl mit Hilfe des Arguments „capacity“ fest­ge­legt wird.
• StringBuilder(CharSequence seq): Generiert einen String­Buil­der mit denselben Zeichen wie die hin­ter­leg­te Char-Sequenz.
• StringBuilder(String str): Erstellt einen String­Buil­der auf Basis des hin­ter­leg­ten Strings.

Die Funk­ti­ons­wei­se der Con­s­truc­tors in der Praxis lässt sich am besten direkt mit einem Code-Beispiel ver­an­schau­li­chen. So funk­tio­nie­ren 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 String­Buil­der in Java

Es gibt zahl­rei­che Methoden für die Java-Klasse String­Buil­der. Einige der wich­tigs­ten stellen wir Ihnen hier mit den passenden Code­aus­schnit­ten vor.

append()

Die Methode append() wird genutzt, um einen String zu einem anderen hin­zu­zu­fü­gen. append() hat un­ter­schied­li­che Parameter. In der Praxis funk­tio­niert 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 Kom­bi­na­ti­on mit dem Java String­Buil­der genutzt, um einen String an einer be­stimm­ten Stelle ein­zu­fü­gen. So sieht das bei­spiel­haft 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 ein­ge­setzt werden soll.

replace()

Die Methode replace() ersetzt einen String oder den Teil eines Strings. Dieser wird durch be­gin­In­dex 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 fol­gen­der­ma­ßen aus:

AFGHIJKE

reverse()

Mit der Methode reverse() drehen Sie den hin­ter­leg­ten String komplett um. Auch dies ver­an­schau­li­chen 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 String­Buil­der in Java verwenden, können Sie den gesamten String oder einen Teil löschen. Diesen Teil de­fi­nie­ren Sie ebenfalls über be­gin­In­dex 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 Zei­chen­an­zahl des Java String­Buil­ders aus. Diese liegt nor­ma­ler­wei­se bei 16. Wird sie erhöht, passiert dies nach der Formel „Bisherige Zei­chen­län­ge * 2 + 2“. Lag sie bisher also bei 16, wird sie nun ver­dop­pelt (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

en­su­re­Ca­pa­ci­ty()

Die Methode ensureCapacity() stellt sicher, dass die ver­füg­ba­re Zei­chen­an­zahl min­des­tens einem de­fi­nier­ten Wert ent­spricht. Ist dies nicht der Fall, wird die Kapazität wieder nach der Formel „Bisherige Zei­chen­län­ge * 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 Stan­dard­wert (16) be­rück­sich­tigt, dann zweimal der doppelte Wert plus zwei (34) und zuletzt der Wert noch einmal ver­dop­pelt und um zwei ergänzt (70).