# Hvordan dele strenger i Java

Metoden `split()` kan brukes til å dele strenger i Java. Den inneholder en parameter for separatoren og en valgfri parameter for antall delstrenger. Det er også noen særtrekk å være oppmerksom på når du bruker metoden. Vi forklarer alt du trenger å vite.

## Hva er `split()`?

[Java-strenger](https://www.ionos.com/nb-no/digitalguide/nettsteder/webutvikling/java-strenger/) sammenføyer tegn, sifre og spesialtegn. De finnes som objekter i klassen java.lang og opprettes og endres med String-klassen. I programmeringsspråket Java kan du også dele opp strenger i forskjellige delstrenger. Java-funksjonen split() brukes til **å trekke ut bestemte segmenter fra en streng** eller dele den opp i **enkeltdeler**. Nedenfor viser vi deg mer detaljert hva du kan gjøre med denne metoden.

Når du deler en Java-streng med split(), får du en matrise med flere strenger. Dette blir returverdien.

## Hva er syntaksen til Java `split()`?

Den grunnleggende syntaksen til Java `split()` er veldig enkel, men kan utvides med valgfrie parametere. Her er den grunnleggende versjonen:

```java
String[] split(String regex)
```

I dette eksemplet **vil utdataene være i form av en matrise**. `String` er strengobjektet. `regex` er parameteren som brukes til å bestemme hvor strengen skal deles. Parameteren er ikke obligatorisk, men anbefales.

Den ekstra valgfrie parameteren `limit` lar deg spesifisere hvor mange delstrenger som skal opprettes. Verdien er et heltall. Hvis den er null eller negativ, vil alle delstrenger bli inkludert i utdataene. Hvis du velger en positiv verdi, vil du få det antallet delstrenger i utdataene. Med den ekstra valgfrie parameteren `limit` vil syntaksen se slik ut:

```java
String[] split(String regex, int limit)
```

## Hvordan bruke `split()` med mellomrom som skilletegn

La oss se på noen praktiske eksempler. Først lager vi en streng som inneholder fire ord: «Dette er et eksempel». Deretter deler vi opp strengen ved hjelp av `split()`. Den mest intuitive måten å dele opp denne strengen på er å bruke de eksisterende **mellomrommene mellom ordene**. Slik gjøres det i koden:

```java
public class Main {
	public static void main(String[] args) {
		String x = "This is an example";
		String[] output = x.split(" ");
		for (String y : output) {
			System.out.println(y);
		}
	}
}
```

I dette eksemplet initialiseres en strengvariabel x. Deretter brukes Java `split()` på strengen. Parameteren søker etter mellomrom i strengen og deler den opp på de stedene hvor den finner dem. Resultatet lagres deretter i en matrise kalt «output». Sløyfen `for` brukes til å liste opp delstrengene. Java-kommandoen `System.out.println` gir oss følgende utdata:

```java
This
is
an
example
```

## Hvordan bruke komma som skilletegn, med og uten mellomrom

Du kan også bruke `split()` i Java med strenger som inneholder **lister atskilt med komma**. Du må bare bruke et lite triks, på grunn av hvor presist instruksjonene dine implementeres i Java. La oss først se på et eksempel uten trikset. La oss si at vi har en liste over ukedagene, atskilt med kommaer. Disse kommaene er perfekte som skilletegn for å legge inn i `regex`. Hvis vi setter opp koden på denne måten, vil den se slik ut:

```java
public class Main {
	public static void main(String[] args) {
		String x = "Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday";
		String[] output = x.split(",");
		for (String y : output) {
			System.out.println(y);
		}
	}
}
```

I dette eksemplet er resultatet ikke helt perfekt:

```java
Sunday
 Monday
 Tuesday
 Wednesday
 Thursday
 Friday
 Saturday
```

Resultatet gir oss en oversiktlig liste over ukedagene. Imidlertid inneholder alle verdiene etter søndag et mellomrom før dagen. Siden vi bare brukte komma som skilletegn, ble mellomrommene stående igjen i delingsprosessen. For å få et renere resultat, bør vi bruke **både komma og mellomrom** som skilletegn. Hvis vi gjør det, vil koden se slik ut:

```java
public class Main {
	public static void main(String[] args) {
		String x = "Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday";
		String[] output = x.split(", ");
		for (String y : output) {
			System.out.println(y);
		}
	}
}
```

Utdataene er nå mye renere:

```java
Sunday
Monday
Tuesday
Wednesday
Thursday
Friday
Saturday
```

## Hvordan dele Java-strenger med sifre

Du kan også bruke `split()` til å dele Java-strenger som består av sifre. I vårt eksempel tar vi en lang nøkkel som er delt ved hjelp av punktum og kolon. Hvis vi ønsker å skille sifrene **etter kolon**, vil koden se slik ut:

```java
public class Main {
	public static void main(String[] args) {
		String x = "194.518.552.1.17:6339";
		String[] output = x.split(":");
		for (String y : output) {
			System.out.println(y);
		}
	}
}
```

Her er resultatet:

```java
194.518.552.1.17
6339
```

## Hvordan bruke `split()` med begrensningsparameteren

Når du deler Java-strenger med `split()`, kan du også bruke den valgfrie `limit`. `limit` begrenser antall delstrenger som opprettes. Det er tre alternativer her: å tildele den en verdi mindre enn 0, 0 eller større enn 0.

### `split()` med en grense mindre enn 0

Hvis du angir en verdi for `limit` som er mindre enn 0, vil det regulære uttrykket bli **brukt uten begrensning på hele strengen**. Den resulterende matrisen kan ha hvilken som helst lengde. Koden kan se slik ut:

```java
public class Main {
	public static void main(String[] args) {
		String x = "Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday ";
		String[] output = x.split(", ", -3);
		for (String y : output) {
			System.out.println(y);
		}
	}
}
```

Siden det er et mellomrom etter det siste ordet «Saturday», vil matrisen ende med en tom streng. Her er resultatet:

```java
Sunday
Monday
Tuesday
Wednesday
Thursday
Friday
Saturday
```

### `split()` med en grense på 0

Hvis du setter parameteren `limit` til 0, vil det regulære uttrykket igjen brukes **så mange ganger som mulig**. Lengden på matrisen er heller ikke begrenset. Men hvis det siste elementet er en tom streng, vil det ikke bli inkludert i den resulterende matrisen.

```java
public class Main {
	public static void main(String[] args) {
		String x = "Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday ";
		String[] output = x.split(", ", 0);
		for (String y : output) {
			System.out.println(y);
		}
	}
}
```

Utdataene ser ut som ovenfor, men uten den siste strengen:

```java
Sunday
Monday
Tuesday
Wednesday
Thursday
Friday
Saturday
```

### `split()` med en grense større enn 0

Forskjellen blir tydeligere når du angir en grense større enn 0. Da vil den bestemme hvor mange delstrenger som kan skrives ut.

```java
public class Main {
	public static void main(String[] args) {
		String x = "Sunday, Monday, Tuesday, Wednesday, Thursday, Friday, Saturday ";
		String[] output = x.split(", ", 3);
		for (String y : output) {
			System.out.println(y);
		}
	}
}
```

Vi får da et resultat som er vesentlig forskjellig fra de ovennevnte:

```java
Sunday
Monday
Tuesday, Wednesday, Thursday, Friday, Saturday
```


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