# Hvordan bruke Java's StringBuilder

Java-klassen StringBuilder kan brukes i stedet for tradisjonelle strenger. I motsetning til tradisjonelle strenger lar StringBuilder deg gjøre endringer i en streng uten å opprette et nytt objekt. Endringene kan gjøres ved hjelp av forskjellige metoder.

## Hva er Java’s StringBuilder?

[Strengklassen i Java](https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/java-strenger/) er uforanderlig og har ingen underklasser. Et alternativ til denne endelige klassen er Javas StringBuilder. Den oppretter en sekvens av tegn som **kan endres etter at den er opprettet**. På denne måten ligner Javas StringBuilder på StringBuffer. De to klassene har et lignende formål, men i motsetning til buffer-alternativet er StringBuilder ikke synkronisert. Det gjør StringBuilder til et godt valg når du arbeider med enkeltråder, da det er mye raskere enn StringBuffer. I denne veiledningen vil vi introdusere deg for StringBuilder i Java og vise deg noen av de mange bruksområdene.

## Hva er syntaksen til Java’s StringBuilder?

Syntaksen til Java’s StringBuilder følger alltid det samme mønsteret, som ser slik ut:

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

For å forstå grunnleggende hvordan klassen fungerer og hvilket formål den tjener, er det nyttig å først se på den tradisjonelle String-klassen. Når du har deklarert et objekt i String, kan du ikke lenger endre det objektet. Hvis du vil gjøre endringer, må du opprette og lagre et helt nytt objekt. Dette skaper mye dataspill og kan føre til redusert ytelse. Hvis du i stedet bruker StringBuilder i Java, kan du gjøre endringer i strenger **uten å opprette en ny**. Dette reduserer sløsing og forbedrer ytelsen.

## Hva er konstruktørene for Java’s StringBuilder?

Java’s StringBuilder har fire konstruktører som hjelper med **å konvertere strengen til riktig format for klassen**. De brukes også til konfigurasjon. Her er de fire konstruktørene og deres formål:

- `StringBuilder()`: Genererer en tom StringBuilder med en maksimal kapasitet på 16 tegn
- `StringBuilder(int capacity)`: Oppretter en StringBuilder uten tegn, hvis maksimale kapasitet er definert ved hjelp av kapasitetsargumentet
- `StringBuilder(CharSequence seq)`: Genererer en strengbygger med de samme tegnene som den lagrede tegnsekvensen
- `StringBuilder(String str)`: Oppretter en StringBuilder med strengen du skriver inn

La oss se på et eksempel for å se hvordan disse konstruktørene 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 bruker Java-kommandoen `System.out.println` for å få utdata, får vi følgende:

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

## Hvilke metoder brukes med StringBuilder i Java?

Det finnes en rekke metoder som kan brukes med Java-klassen StringBuilder. Nedenfor presenterer vi noen av de viktigste, med kodeeksempler.

### `append()`

Metoden `append()` brukes til å legge til en streng til en annen. Den har ulike parametere. Slik 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);
	}
}
```

Resultatet er som følger:

```java
ABCDEFGHIJK
```

### `insert()`

Metoden `insert()` brukes i kombinasjon med Java’s StringBuilder for å sette inn en streng på et bestemt punkt. 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 tilfellet 1) brukes til å definere posisjonen der strengen skal settes inn.

### `replace()`

Metoden `replace()` erstatter en streng eller en del av en streng. Den defineres ved hjelp av `beginIndex` og `endIndex`. Slik fungerer den 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 slik ut:

```java
AFGHIJKE
```

### `reverse()`

Metoden `reverse()` brukes til å sette den lagrede strengen i omvendt rekkefølge. Slik 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 bruke `delete()` metoden med Java’s StringBuilder til å slette hele eller deler av en streng. Hvis du vil slette deler av strengen, kan du gjø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()` gir deg det **gjeldende maksimale antallet tegn** for StringBuilder. Normalt er dette 16. Hvis det økes, gjøres det vanligvis ved hjelp av formelen «gjeldende antall tegn \* 2 + 2». Så hvis det for øyeblikket er 16, multipliseres det med 2 (32) og deretter legges 2 til. Du kan se det i eksemplet vårt:

```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 slik ut:

```java
16
16
34
```

### `ensureCapacity()`

Metoden `ensureCapacity()` sikrer at **antall tilgjengelige tegn er minst like stort som den definerte verdien**. Hvis det ikke er tilfelle, økes kapasiteten ved hjelp av formelen ovenfor, «nåværende antall tegn \* 2 + 2». Du kan se det 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 standardverdien (16), deretter den verdien multiplisert med 2 og lagt til 2 (34), og til slutt den nye verdien multiplisert med 2 og lagt til 2.


This is a markdown version of: [https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/java-stringbuilder/](https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/java-stringbuilder/) for AI/LLM consumption.