# 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](https://www.ionos.com/de-ch/digitalguide/websites/web-entwicklung/java-strings/) 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:

```java
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:

```java
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:

```java
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:

```java
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:

```java
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:

```java
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:

```java
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:

```java
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:

```java
AFGHIJKE
```

### reverse()

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

```java
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:

```java
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:

```java
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:

```java
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:

```java
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:

```java
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:

```java
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:

```java
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).


This is a markdown version of: [https://www.ionos.com/de-ch/digitalguide/websites/web-entwicklung/java-stringbuilder/](https://www.ionos.com/de-ch/digitalguide/websites/web-entwicklung/java-stringbuilder/) for AI/LLM consumption.