# Sådan bruges Java's StringBuilder

Java’s StringBuilder-klasse kan bruges i stedet for traditionelle strenge. I modsætning til traditionelle strenge giver StringBuilder dig mulighed for at foretage ændringer i en streng uden at oprette et nyt objekt. Ændringerne kan foretages ved hjælp af forskellige metoder.

## Hvad er Java’s StringBuilder?

[String-klassen i Java](https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/java-strenge/) er uforanderlig og har ingen underklasser. Et alternativ til denne endelige klasse er Java’s StringBuilder. Den opretter en sekvens af tegn, der **kan ændres, efter at den er oprettet**. På denne måde ligner Java’s StringBuilder StringBuffer. De to klasser har et lignende formål, men i modsætning til buffer-optionen er StringBuilder ikke synkroniseret. Det gør StringBuilder til et godt valg, når man arbejder med enkelt-tråde, da det er meget hurtigere end StringBuffer. I denne tutorial introducerer vi dig til StringBuilder i Java og viser dig nogle af dens mange anvendelsesmuligheder.

## Hvad er syntaksen for Java’s StringBuilder?

Syntaksen i Java’s StringBuilder følger altid det samme mønster, som ser således ud:

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

For at forstå grundlæggende, hvordan klassen fungerer, og hvilket formål den tjener, er det en god idé først at se på den traditionelle String-klasse. Når du har deklareret et objekt i String, kan du ikke længere ændre det objekt. Hvis du vil foretage ændringer, skal du oprette og gemme et helt nyt objekt. Dette skaber en masse dataspild og kan føre til nedsat ydeevne. Hvis du i stedet bruger StringBuilder i Java, kan du foretage ændringer i strenge **uden at oprette en ny**. Dette reducerer spild og forbedrer ydeevnen.

## Hvad er konstruktørerne for Java’s StringBuilder?

Java’s StringBuilder har 4 konstruktører, der hjælper med **at konvertere strengen til det rigtige format for klassen**. De bruges også til konfiguration. Her er de fire konstruktører og deres formål:

- `StringBuilder()`: Genererer en tom StringBuilder med en maksimal kapacitet på 16 tegn
- `StringBuilder(int capacity)`: Opretter en StringBuilder uden tegn, hvis maksimale kapacitet er defineret ved hjælp af kapacitetsargumentet
- `StringBuilder(CharSequence seq)`: Genererer en string builder med de samme tegn som den gemte tegnsekvens
- `StringBuilder(String str)`: Opretter en StringBuilder med den streng, du indtaster

Lad os se på et eksempel for at se, hvordan disse konstruktører fungerer i praksis:

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

Når vi bruger Java-kommandoen `System.out.println` til at få outputtet, får vi følgende:

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

## Hvilke metoder bruges med StringBuilder i Java?

Der findes en række metoder, der kan bruges med Java’s StringBuilder-klasse. Nedenfor introducerer vi nogle af de vigtigste med kodeeksempler.

### `append()`

Metoden `append()` bruges til at tilføje en streng til en anden. Den har forskellige parametre. Sådan fungerer den i praksis:

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

Outputtet er som følger:

```java
ABCDEFGHIJK
```

### `insert()`

Metoden `insert()` bruges i kombination med Java’s StringBuilder til at indsætte en streng på et bestemt sted. Her er et eksempel på, hvordan det fungerer:

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

Her er resultatet:

```java
AFGHIJKBCDEFGHIJK
```

Heltallet (i dette tilfælde 1) bruges til at definere den position, hvor strengen skal indsættes.

### `replace()`

Metoden `replace()` erstatter en streng eller en del af en streng. Den defineres ved hjælp af `beginIndex` og `endIndex`. Sådan fungerer det i praksis:

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

Resultatet ser således ud:

```java
AFGHIJKE
```

### `reverse()`

Metoden `reverse()` bruges til at placere den gemte streng i omvendt rækkefølge. Sådan fungerer det:

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

Her er resultatet:

```java
EDCBA
```

### `delete()`

Du kan bruge metoden `delete()` med Java’s StringBuilder til at slette hele eller en del af en streng. Hvis du vil slette en del af strengen, kan du gøre det med `beginIndex` og `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);
	}
}
```

Her er resultatet:

```java
AE
```

### `capacity()`

Metoden `capacity()` giver dig det **aktuelle maksimale tegnantal** for StringBuilder. Det er normalt 16. Hvis det øges, sker det normalt ved hjælp af formlen ‘aktuelt tegnantal \* 2 + 2’. Så hvis det i øjeblikket er 16, ganges det med 2 (32) og derefter lægges 2 til. Det kan du se i vores eksempel:

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

Resultatet ser således ud:

```java
16
16
34
```

### `ensureCapacity()`

Metoden `ensureCapacity()` sikrer, at **antallet af tilgængelige tegn mindst svarer til den definerede værdi**. Hvis dette ikke er tilfældet, øges kapaciteten ved hjælp af formlen ovenfor, ‘aktuel tegnantal \* 2 + 2’. Dette kan ses i følgende eksempel:

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

Her er resultatet:

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

Først ser vi standardværdien (16), derefter den værdi ganget med 2 og lagt til 2 (34), og til sidst den nye værdi ganget med 2 og lagt til 2.


This is a markdown version of: [https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/java-stringbuilder/](https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/java-stringbuilder/) for AI/LLM consumption.