# Hoe strings splitsen in Java

De methode `split()` kan worden gebruikt om strings in Java te splitsen. Deze bevat een parameter voor het scheidingsteken en een optionele parameter voor het aantal substrings. Er zijn ook enkele bijzonderheden waar u rekening mee moet houden bij het gebruik van de methode. We leggen u alles uit wat u moet weten.

## Wat is `split()`?

[Java-strings](https://www.ionos.com/nl-be/digitalguide/websites/webontwikkeling/java-strings/) voegen tekens, cijfers en speciale tekens samen. Ze bestaan als objecten in de klasse java.lang en worden aangemaakt en gewijzigd met de klasse String. In de programmeertaal Java kunt u strings ook opsplitsen in verschillende substrings. De methode split() van Java wordt gebruikt om **bepaalde segmenten uit een string te extraheren** of om deze in **afzonderlijke delen** op te splitsen. Hieronder laten we u in meer detail zien wat u met deze methode kunt doen.

Wanneer je een Java-string splitst met split(), krijg je een array met verschillende strings. Dit wordt de retourwaarde.

## Wat is de syntaxis van Java `split()`?

De basissyntaxis van Java `split()` is heel eenvoudig, maar kan worden uitgebreid met optionele parameters. Hier is de basisversie:

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

In dit voorbeeld **zal de uitvoer de vorm van een array hebben**. `String` is het stringobject. `regex` is de parameter die wordt gebruikt om te bepalen waar de string moet worden gesplitst. De parameter is niet verplicht, maar wordt wel aanbevolen.

Met de extra optionele parameter `limit` kunt u aangeven hoeveel substrings er moeten worden gemaakt. De waarde ervan is een geheel getal. Als deze nul of negatief is, worden alle substrings in de uitvoer opgenomen. Als u een positieve waarde kiest, krijgt u dat aantal substrings in de uitvoer. Met de extra optionele parameter `limit` ziet de syntaxis er als volgt uit:

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

## Hoe gebruik je `split()` met een spatie als scheidingsteken?

Laten we eens kijken naar enkele praktische voorbeelden. Eerst maken we een string met vier woorden: ‘Dit is een voorbeeld’. Vervolgens splitsen we de string op met behulp van `split()`. De meest intuïtieve manier om deze string op te splitsen is door gebruik te maken van de reeds bestaande **spaties tussen de woorden**. Zo gebeurt dat in de code:

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

In dit voorbeeld wordt een stringvariabele x geïnitialiseerd. Vervolgens wordt Java’s `split()` op de string toegepast. De parameter zoekt naar spaties in de string en splitst deze op de plaatsen waar hij spaties vindt. Het resultaat wordt vervolgens opgeslagen in een array met de naam ‘output’. De `for` wordt gebruikt om de substring te weergeven. Het Java-commando `System.out.println` geeft ons de volgende uitvoer:

```java
This
is
an
example
```

## Hoe gebruik je een komma als scheidingsteken, met en zonder spaties

Je kunt `split()` ook gebruiken in Java met strings die **lijsten** bevatten **die door komma’s worden gescheiden**. Je moet alleen een klein trucje gebruiken, vanwege de nauwkeurigheid waarmee je instructies in Java worden geïmplementeerd. Laten we eerst eens kijken naar een voorbeeld zonder het trucje. Stel dat we een lijst hebben met de dagen van de week, gescheiden door komma’s. Deze komma’s zijn de perfecte scheidingstekens om in `regex` in te voeren. Als we de code op deze manier opstellen, ziet deze er als volgt uit:

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

In dit voorbeeld is de uitvoer niet helemaal perfect:

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

De uitvoer geeft ons een duidelijke lijst van de dagen van de week. Elke waarde na zondag bevat echter een spatie voor de dag. Omdat we alleen een komma als scheidingsteken hebben gebruikt, zijn de spaties tijdens het splitsen blijven staan. Om een nettere uitvoer te krijgen, moeten we **zowel een komma als een spatie** als scheidingsteken gebruiken. Als we dat doen, ziet de code er als volgt uit:

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

De uitvoer is nu veel overzichtelijker:

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

## Hoe Java-strings met cijfers splitsen

Je kunt `split()` ook gebruiken om Java-strings bestaande uit cijfers op te splitsen. In ons voorbeeld nemen we een lange sleutel die is opgedeeld met punten en een dubbele punt. Als we de cijfers **na de dubbele punt** willen scheiden, ziet de code er als volgt uit:

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

Dit is de uitvoer:

```java
194.518.552.1.17
6339
```

## Hoe gebruik je `split()` met de limietparameter?

Bij het splitsen van Java-strings met `split()` kunt u ook de optionele parameter `limit` gebruiken. De parameter `limit` beperkt het aantal substring dat wordt aangemaakt. Hier zijn drie opties: een waarde kleiner dan 0, 0 of groter dan 0 toekennen.

### `split()` met een limiet kleiner dan 0

Als u voor `limit` een waarde invoert die kleiner is dan 0, wordt de reguliere expressie **zonder beperking op de hele tekenreeks toegepast**. De resulterende array kan elke lengte hebben. Die code zou er als volgt uit kunnen zien:

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

Aangezien er een spatie staat na het laatste woord ‘Saturday’, eindigt de array met een lege string. Dit is de uitvoer:

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

### `split()` met een limiet van 0

Als u de parameter `limit` op 0 instelt, wordt de reguliere expressie weer **zo vaak mogelijk** gebruikt. De lengte van de array is ook niet beperkt. Maar als het laatste element een lege tekenreeks is, wordt deze niet opgenomen in de 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);
		}
	}
}
```

De uitvoer ziet er ongeveer hetzelfde uit als hierboven, maar dan zonder de laatste string:

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

### `split()` met een limiet groter dan 0

Het verschil wordt duidelijker wanneer u een limiet instelt die groter is dan 0. Dan bepaalt het hoeveel substrings kunnen worden uitgevoerd.

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

We krijgen dan een uitvoer die aanzienlijk verschilt van de bovenstaande uitvoer:

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


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