# Sådan opdeles strenge i Java

Metoden `split()` kan bruges til at opdele strenge i Java. Den indeholder en parameter for separatoren og en valgfri parameter for antallet af delstrenge. Der er også nogle særlige forhold, man skal være opmærksom på, når man bruger metoden. Vi forklarer alt, hvad du behøver at vide.

## Hvad er `split()`?

[Java-strenge](https://www.ionos.com/da-dk/digitalguide/websteder/webudvikling/java-strenge/) sammenkæder tegn, cifre og specialtegn. De findes som objekter i klassen java.lang og oprettes og ændres med klassen String. I programmeringssproget Java kan du også opdele strenge i forskellige delstrenge. Java’s split() bruges til **at udtrække bestemte segmenter fra en streng** eller til at opdele den i **individuelle dele**. Nedenfor viser vi dig mere detaljeret, hvad du kan gøre med metoden.

Når du opdeler en Java-streng med split(), får du en matrix med flere strenge. Dette bliver returværdien.

## Hvad er syntaksen i Java `split()`?

Den grundlæggende syntaks i Java `split()` er meget enkel, men kan udvides med valgfri parametre. Her er den grundlæggende version:

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

I dette eksempel **vil outputtet være i form af en matrix**. `String` er strengobjektet. `regex` er den parameter, der bruges til at bestemme, hvor strengen skal opdeles. Parameteren er ikke obligatorisk, men anbefales.

Den ekstra valgfri parameter `limit` giver dig mulighed for at angive, hvor mange delstrenge der skal oprettes. Dens værdi er et heltal. Hvis den er nul eller negativ, vil alle delstrenge blive inkluderet i outputtet. Hvis du vælger en positiv værdi, vil du få det antal delstrenge i outputtet. Med den ekstra valgfri parameter `limit` vil syntaksen se således ud:

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

## Sådan bruges `split()` med mellemrum som separator

Lad os se på nogle praktiske eksempler. Først opretter vi en streng, der indeholder 4 ord: ‘Dette er et eksempel’. Derefter opdeler vi strengen ved hjælp af `split()`. Den mest intuitive måde at opdele denne streng på er at bruge de allerede eksisterende **mellemrum mellem ordene**. Sådan sker 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 eksempel initialiseres en strengvariabel x. Derefter bruges Java’s `split()` på strengen. Parameteren søger efter mellemrum i strengen og opdeler den de steder, hvor den finder dem. Resultatet gemmes derefter i en matrix kaldet ‘output’. `for` bruges til at liste delstrengene. Java-kommandoen `System.out.println` giver os følgende output:

```java
This
is
an
example
```

## Sådan bruges komma som separator, med og uden mellemrum

Du kan også bruge `split()` i Java med strenge, der indeholder **lister adskilt af kommaer**. Du skal bare bruge et lille trick, fordi dine instruktioner implementeres meget præcist i Java. Lad os først se på et eksempel uden tricket. Lad os sige, at vi har en liste over ugedagene, adskilt af kommaer. Disse kommaer er den perfekte separator til at indtaste i `regex`. Hvis vi opsætter koden på denne måde, vil den se således ud:

```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 eksempel er resultatet ikke helt perfekt:

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

Outputtet giver os en overskuelig liste over ugens dage. Dog indeholder alle værdier efter søndag et mellemrum før dagen. Da vi kun brugte komma som separator, blev mellemrummene stående i opdelingsprocessen. For at få et mere overskueligt output bør vi bruge **både komma og mellemrum** som separator. Hvis vi gør det, vil koden se således ud:

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

Outputtet er nu meget renere:

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

## Sådan opdeles Java-strenge med cifre

Du kan også bruge `split()` til at opdele Java-strenge, der består af cifre. I vores eksempel tager vi en lang nøgle, der er opdelt ved hjælp af punktummer og kolon. Hvis vi vil adskille cifrene **efter kolon**, vil koden se sådan ud:

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

## Sådan bruges `split()` med parameteren limit

Når du opdeler Java-strenge med `split()`, kan du også bruge den valgfri `limit`. `limit` begrænser antallet af understrenge, der oprettes. Der er tre muligheder her: at tildele den en værdi mindre end 0, 0 eller større end 0.

### `split()` med en grænse på mindre end 0

Hvis du indtaster en værdi for `limit`, der er mindre end 0, vil det regulære udtryk blive **anvendt uden begrænsning på hele strengen**. Det resulterende array kan have en vilkårlig længde. Den kode kan se således ud:

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

Da der er et mellemrum efter det sidste ord ‘Saturday’, slutter arrayet med en tom streng. Her er resultatet:

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

### `split()` med en grænse på 0

Hvis du indstiller parameteren `limit` til 0, vil det regulære udtryk igen blive brugt **så mange gange som muligt**. Længden af arrayet er heller ikke begrænset. Men hvis det sidste element er en tom streng, vil det ikke blive inkluderet i det resulterende array.

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

Outputtet ligner ovenstående, men uden den sidste streng:

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

### `split()` med en grænse større end 0

Forskellen bliver mere tydelig, når du indstiller en grænse større end 0. Derefter bestemmer den, hvor mange delstrenge der kan udskrives.

```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 derefter et resultat, der adskiller sig markant fra ovenstående:

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


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