# Hoe gebruik je Java's StringBuilder?

De StringBuilder-klasse van Java kan worden gebruikt in plaats van traditionele strings. In tegenstelling tot traditionele strings kunt u met StringBuilder wijzigingen aanbrengen in een string zonder een nieuw object te maken. De wijzigingen kunnen met verschillende methoden worden aangebracht.

## Wat is Java’s StringBuilder?

De [stringklasse in Java](https://www.ionos.com/nl-be/digitalguide/websites/webontwikkeling/java-strings/) is onveranderlijk en heeft geen subklassen. Een alternatief voor deze definitieve klasse is Java’s StringBuilder. Deze maakt een reeks tekens aan die **na het aanmaken nog kan worden gewijzigd**. In dit opzicht lijkt Java’s StringBuilder op StringBuffer. De twee klassen hebben een vergelijkbaar doel, maar in tegenstelling tot de bufferoptie wordt StringBuilder niet gesynchroniseerd. Dat maakt StringBuilder een goede keuze bij het werken met enkele threads, omdat het veel sneller is dan StringBuffer. In deze tutorial laten we u kennismaken met StringBuilder in Java en laten we u enkele van de vele toepassingen zien.

## Wat is de syntaxis van Java’s StringBuilder?

De syntaxis van Java’s StringBuilder volgt altijd hetzelfde patroon, dat er als volgt uitziet:

```java
public final class StringBuilder
	extends Object
		implements Serializable, CharSequence
```

Om de basisprincipes van hoe de klasse werkt en welk doel deze dient te begrijpen, is het handig om eerst naar de traditionele String-klasse te kijken. Zodra u een object in String hebt gedeclareerd, kunt u dat object niet meer wijzigen. Als u wijzigingen wilt aanbrengen, moet u een geheel nieuw object maken en opslaan. Dit leidt tot veel verspilling van gegevens en kan de prestaties verminderen. Als je in plaats daarvan StringBuilder in Java gebruikt, kun je wijzigingen aanbrengen in strings **zonder een nieuwe te maken**. Dit vermindert verspilling en verbetert de prestaties.

## Wat zijn de constructors voor Java’s StringBuilder?

Java’s StringBuilder heeft 4 constructors die helpen bij **het converteren van de string naar het juiste formaat voor de klasse**. Ze worden ook gebruikt voor configuratie. Hier zijn de vier constructors en hun doeleinden:

- `StringBuilder()`: Genereert een lege StringBuilder met een maximale capaciteit van 16 tekens
- `StringBuilder(int capacity)`: Maakt een StringBuilder zonder tekens waarvan de maximale capaciteit wordt gedefinieerd met behulp van het capaciteitsargument
- `StringBuilder(CharSequence seq)`: Genereert een string builder met dezelfde tekens als de opgeslagen tekenreeks
- `StringBuilder(String str)`: Maakt een StringBuilder met de string die u invoert

Laten we eens kijken naar een voorbeeld om te zien hoe deze constructors in de praktijk werken:

```java
public class Main {
	public static void main(String[] argv) throws Exception {
	StringBuilder str = new StringBuilder();
	str.append("ABC");
	System.out.println("First constructor  = " + str.toString());
	StringBuilder str2 = new StringBuilder(5);
	System.out.println("Second constructor  = " + str2.capacity());
	StringBuilder str3 = new StringBuilder("ABCDEFGHIJK");
	System.out.println("Third constructor = " + str3.toString());
	StringBuilder str4 = new StringBuilder(str3.toString());
	System.out.println("Fourth constructor = " + str4.toString());
	}
}
```

Wanneer we het Java-commando `System.out.println` gebruiken om de uitvoer te krijgen, krijgen we het volgende:

```java
First constructor = ABC
Second constructor = 5
Third constructor = ABCDEFGHIJK
Fourth constructor = ABCDEFGHIJK
```

## Welke methoden worden gebruikt met StringBuilder in Java?

Er zijn een aantal methoden die kunnen worden gebruikt met de StringBuilder-klasse van Java. Hieronder introduceren we enkele van de belangrijkste, met codevoorbeelden.

### `append()`

De `append()` wordt gebruikt om de ene string aan de andere toe te voegen. Deze methode heeft verschillende parameters. Zo werkt het in de praktijk:

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

De uitvoer is als volgt:

```java
ABCDEFGHIJK
```

### `insert()`

De `insert()` wordt gebruikt in combinatie met Java’s StringBuilder om een string op een specifiek punt in te voegen. Hier is een voorbeeld van hoe het werkt:

```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);
	}
}
```

Dit is de uitvoer:

```java
AFGHIJKBCDEFGHIJK
```

Het gehele getal (in dit geval 1) wordt gebruikt om de positie te definiëren waar de tekenreeks wordt ingevoegd.

### `replace()`

De methode `replace()` vervangt een tekenreeks of een deel van een tekenreeks. Deze wordt gedefinieerd met behulp van `beginIndex` en `endIndex`. Zo werkt het in de praktijk:

```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);
	}
}
```

De uitvoer ziet er als volgt uit:

```java
AFGHIJKE
```

### `reverse()`

De `reverse()` -methode wordt gebruikt om de opgeslagen tekenreeks in omgekeerde volgorde te plaatsen. Zo werkt het:

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

Dit is de uitvoer:

```java
EDCBA
```

### `delete()`

Je kunt de `delete()` gebruiken met Java’s StringBuilder om een string geheel of gedeeltelijk te verwijderen. Als je een deel van de string wilt verwijderen, kun je dat doen met `beginIndex` en `endIndex`.

```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);
	}
}
```

Dit is de uitvoer:

```java
AE
```

### `capacity()`

`capacity()` geeft je het **huidige maximale aantal tekens** voor StringBuilder. Normaal gesproken is dat 16. Als dit wordt verhoogd, gebeurt dat meestal met behulp van de formule ‘huidig aantal tekens \* 2 + 2’. Dus als het momenteel 16 is, wordt het vermenigvuldigd met 2 (32) en wordt er vervolgens 2 bij opgeteld. Dat kun je zien in ons voorbeeld:

```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("This is another example");
	System.out.println(str.capacity());
	}
}
```

De uitvoer ziet er als volgt uit:

```java
16
16
34
```

### `ensureCapacity()`

`ensureCapacity()` zorgt ervoor dat het **aantal beschikbare tekens minimaal gelijk is aan de gedefinieerde waarde**. Als dat niet het geval is, wordt de capaciteit vergroot met behulp van de bovenstaande formule: ‘huidig aantal tekens \* 2 + 2’. Dat kunt u zien in het volgende voorbeeld:

```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("This is another example");
	System.out.println(str.capacity());
	str.ensureCapacity(5);
	System.out.println(str.capacity());
	str.ensureCapacity(40);
	System.out.println(str.capacity());
	}
}
```

Dit is de uitvoer:

```java
16
16
34
34
70
```

Eerst zien we de standaardwaarde (16), vervolgens wordt die waarde vermenigvuldigd met 2 en opgeteld bij 2 (34), en ten slotte wordt die nieuwe waarde vermenigvuldigd met 2 en opgeteld bij 2.


This is a markdown version of: [https://www.ionos.com/nl-be/digitalguide/websites/webontwikkeling/java-stringbuilder/](https://www.ionos.com/nl-be/digitalguide/websites/webontwikkeling/java-stringbuilder/) for AI/LLM consumption.