Allgemeines
Objekte der Klasse String können nicht verändert werden, sie sind immutable. Wenn wir den Wert eines Strings verändern wollen, müssen wir einen neuen String erzeugen, während der alte bestehen bleibt.
Mit den beiden Klassen StringBuilder und StringBuffer ist das etwas Anderes.
Beide Klassen ähneln sich sehr stark und haben die gleichen Methoden, unterscheiden sich nur etwas im Einsatzzweck. Für die meisten Zwecke reicht StringBuilder, sein Zeitverhalten ist etwas günstiger. StringBuffer ist etwas langsamer, kommt dafür aber besser mit Threads zurecht.
Einen einfachen String können wir ohne den new-Operator erzeugen. Ein Objekt der Klasse StringBuilder müssen wir aber wie jedes andere Objekt erzeugen:
StringBuilder name = new StringBuilder("Helmich");
Während ein String genau so viel Speicherplatz belegt, wie er für die Zeichen der Zeichenkette benötigt, kann ein Objekt der Klasse StringBuilder seinen Speicherplatz dynamisch vergrößern - ähnlich wie bei einer ArrayList. Diese Dynamik ist einerseits sehr vorteilhaft, kostet andererseits aber auch Rechenzeit. Bei zeitkritischen Anwendungen sollte man sich also gut überlegen, ob man String-Objekte oder StringBuilder-Objekte einsetzt.
Konstruktoren
Wichtige Methoden
Weitere Methoden
Weitere Methoden finden Sie in der Original-Dokumentation der Klasse String auf der Webseite von Oracle.
Konstruktoren im Detail
StringBuilder()↑
Das ist der einfachste Konstruktor der Klasse StringBuilder, mit dem man auf einfache Weise ein leeres Objekt sb erzeugen kann.
StringBuilder sb = new StringBuilder();
sb.append("Hallo");
StringBuilder(int capacity)↑
Erzeugt ein leeres StringBuilder-Objekt sb mit der angegebenen Anfangskapazität.
StringBuilder sb = new StringBuilder(50);
sb.append("Kapazität-Test");
System.out.println(sb);
System.out.println("Kapazität: " + sb.capacity());
Hier wird in der ersten Zeile eine leere Zeichenkette für maximal 50 Zeichen erzeugt.
In der zweiten Zeile wird ein String an das Ende der leeren Zeichenkette angehängt.
In der vierten Zeile wird die Kapazität ausgegeben: 50. Durch das "Anhängen" an die leere Zeichenkette hat sich die Kapazität also nicht verändert. Das geschieht erst, wenn die Länge der Zeichenkette größer ist als die bisher vorhandene Kapazität, dann wird die Kapazität entsprechend vergrößert.
StringBuilder(String str)↑
Erzeugt ein StringBuilder-Objekt sb, das mit dem angegebenen String initialisiert wird. Die Anfangskapazität beträgt str.length() + 16.
StringBuilder sb = new StringBuilder("Java");
System.out.println(sb);
System.out.println("Kapazität: " + sb.capacity());
System.out.println("Länge: " + sb.length());
Nach der Erzeugung des Objekts in der Zeile 1 und der Ausgabe von "Java" in der Zeile 2 wird durch den println()-Befehl in der Zeile 3 eine Kapazität von 20 ausgegeben: Der String "Java" hat eine Länge von 4, und 16 freie Stellen für weitere Zeichen werden an "Java" angehängt.
Die Codebeispiele in diesem Abschnitt wurden übrigens von ChatGPT generiert und von mir dann mit BlueJ überprüft und gegebenenfalls angepasst.
Methoden im Detail
append(Datentyp d)↑
Syntax:
public void append(Datentyp: d)
Rückgabewert:
---
Funktion:
Hängt eine Zahl, einen String oder einen anderen Datentyp an die Zeichenkette an.
Codebeispiel 1:
StringBuilder sb = new StringBuilder("Java");
sb.append(true); // boolean
sb.append(3.14); // double
sb.append("Hallo"); // Stromg
sb.append('!'); // char
Hier sehen wir vier Beispiele für die enorme Vielfalt der append()-Methode. Wenn Sie noch mehr Möglichkeiten sehen wollen, gehen Sie einfach auf die Oracle-Dokumentation der Klasse StringBuilder.
Interessant ist das folgende Codebeispiel:
Codebeispiel 2:
int zahl1 = 42;
double zahl2 = 3.14;
StringBuilder sb = new StringBuilder("Die Antwort ist ");
sb.append(zahl1).append(" und Pi ist ungefähr ").append(zahl2);
System.out.println(sb);
// Ausgabe: "Die Antwort ist 42 und Pi ist ungefähr 3.14"
Hier sehen wir eine Verkettung von drei append()-Aufrufen in der selben Anweisung. Eine solche Methoden-Verkettung ist zwar kein guter Programmierstil, soll aber die Mächtigkeit des append()-Befehls verdeutlichen.
capacity()↑
Syntax:
public int capacity()
Anmerkungen:
Gibt die aktuelle Kapazität zurück. Die Kapazität ist die Menge an Speicher, die für neu eingefügte Zeichen zur Verfügung steht; wenn diese überschritten wird, erfolgt eine Speicherallokation. Nicht zu verwechseln mit length() , diese Methode gibt die tatsächlich beanspruchte Zahl von Speicherplätzen zurück (genau wie bei der Klasse String).
Codebeispiel:
StringBuilder sb = new StringBuilder();
System.out.println("Anfangskapazität: " + sb.capacity());
StringBuilder sb2 = new StringBuilder("Hallo");
System.out.println("Kapazität mit Starttext: " + sb2.capacity());
sb2.append(" und willkommen im Java-Kurs!");
System.out.println("Neue Kapazität nach Überschreiten: " + sb2.capacity());
Konsolenausgabe:
Anfangskapazität: 16 Kapazität mit Starttext: 21 Neue Kapazität nach Überschreiten: 44
delete()↑
Syntax:
public void delete(int start, int end)
Rückgabewert:
---
Funktion:
Entfernt einen Substring ab der start-Position (inklusiv) bis zur end-Position (exklusiv). Die Methode gibt eine Referenz auf dasselbe StringBuilder-Objekt zurück, was Methodenverkettung ("chaining") ermöglicht.
Codebeispiel 1:
StringBuilder sb = new StringBuilder("Programmieren macht Spaß");
sb.delete(13, 19);
System.out.println(sb);
// Ausgabe: Programmieren Spaß
Codebeispiel 2:
StringBuilder sb = new StringBuilder("Programmieren macht wirklich sehr viel Spaß");
// Zuerst löschen wir "wirklich ", dann "sehr "
sb.delete(20, 29).delete(20, 25);
System.out.println(sb);
// Ausgabe: Programmieren macht viel Spaß
Hier sehen wir ein Beispiel für die sogenannte Methodenverkettung.
deleteCharAt()↑
Syntax:
public void deleteCharAt(int index)
Rückgabewert:
---
Funktion:
Entfernt ein einzelnes Zeichen an der Position index.
Codebeispiel:
StringBuilder sb = new StringBuilder("Hallo");
sb.deleteCharAt(1);
System.out.println(sb);
// Ausgabe: Hllo indexOf()↑
Syntax:
public int indexOf(String str)
Rückgabewert:
int
Funktion:
Sucht nach dem ersten Vorkommen des übergebenen Strings und gibt dessen Start-Index zurück. Falls der String nicht gefunden wird, ist der Rückgabewert -1.
Codebeispiel:
StringBuilder sb = new StringBuilder("Das ist ein Test");
int pos = sb.indexOf("Test");
System.out.println("Position: " + pos);
// Ausgabe: "Position: 11" insert()↑
Syntax:
public void insert(int index, String str)
Rückgabewert:
---
Funktion:
Fügt den übergebenen String str an der durch index angegebenen Position in die Zeichenkette ein. Die nachfolgenden Zeichen werden nach hinten verschoben.
Codebeispiel:
StringBuilder sb = new StringBuilder("Java Programmierung");
sb.insert(5, "OOP ");
System.out.println(sb);
// Ausgabe: Java OOP Programmierung lastIndexOf()↑
Syntax:
public int lastIndexOf(String str)
Rückgabewert:
int
Funktion:
Sucht nach dem letzten Vorkommen des übergebenen Strings und gibt dessen Start-Index zurück. Falls der String nicht gefunden wird, ist der Rückgabewert -1.
Codebeispiel:
StringBuilder sb = new StringBuilder("abc abc abc");
int pos = sb.lastIndexOf("abc");
System.out.println("Letzte Position: " + pos);
// Ausgabe: "Letzte Position: 8" replace()↑
Syntax:
public void replace(int start, int end, String str)
Rückgabewert:
---
Funktion:
Ersetzt den Zeichenbereich von start (inklusiv) bis end (exklusiv) durch den Inhalt des übergebenen Strings str.
Codebeispiel:
StringBuilder sb = new StringBuilder("Guten Morgen");
sb.replace(6, 12, "Abend");
System.out.println(sb);
// Ausgabe: Guten Abend
reverse()↑
Syntax:
public void reverse()
Rückgabewert:
---
Funktion:
Kehrt die Reihenfolge der Zeichen in der Zeichenkette um.
Codebeispiel:
StringBuilder sb = new StringBuilder("Hallo");
sb.reverse();
System.out.println(sb);
// Ausgabe: "ollaH" setLength()↑
Syntax:
public void setLength(int newLength)
Rückgabewert:
---
Funktion:
Die Länge der Zeichenkette wird auf die neue Länge gesetzt. Dabei werden eventuell die letzten Zeichen abgeschnitten, fals die neue Länge kleiner ist als die alte Länge. Wenn die neue Länge größer ist als die alte, werden am Ende der Zeichenkette Nullzeichen angehängt (\u0000), keine Leerzeichen!
Codebeispiel:
StringBuilder sb = new StringBuilder("Hallo Welt");
sb.setLength(5);
System.out.println(sb);
// Ausgabe: Hallo
sb.setLength(10);
System.out.println(sb);
// Ausgabe: Hallo_____ (mit 5 Nullzeichen \u0000 am Ende) subString()↑
Syntax:
a) public String subString(int start)
b) public String subString(int start, int end)
Rückgabewert:
String
Funktion:
a) Gibt einen Substring zurück, der bei dem Index start beginnt und bis zum Ende der Zeichenkette geht. Das ursprüngliche StringBuilder-Objekt wird nicht verändert.
b) Wie a), aber der Substring endet eine Position vor dem übergebenem Index end.
Codebeispiel:
StringBuilder sb = new StringBuilder("Informatik");
String teil = sb.substring(3, 7);
System.out.println(teil); // ⟹ "orma trimToSize()↑
Syntax:
public void trimToSize()
Rückgabewert:
String
Funktion:
Die interne Speicherkapazität des Objekts wird auf die aktuell genutzte Länge reduziert. Da wundert man sich etwas, warum die Methode nicht trimToLength() heißt.
Codebeispiel:
StringBuilder sb = new StringBuilder(100);
sb.append("Hallo");
System.out.println("Kapazität vorher: " + sb.capacity()); // ⟹ 100
sb.trimToSize();
System.out.println("Kapazität nachher: " + sb.capacity()); // ⟹ 5 Quellen:
- Habelitz: Programmieren lernen mit Java, 8. Auflage, Rheinwerk-Verlag Bonn 2025.