# Java: Die String-split()-Methode und ihr praktischer Nutzen

Die Java-Methode String split() wird genutzt, um Strings in mehrere Teilstrings zu zerlegen. Dabei wird ein Parameter festgelegt, der als Trennzeichen fungiert. Ein optionaler Parameter regelt die Anzahl der Teilstrings. Beim Einsatz der Methode gibt es einige beachtenswerte Besonderheiten.

## Was ist die Methode Java String split()?

Ein [Java String](https://www.ionos.com/de-ch/digitalguide/websites/web-entwicklung/java-strings/) verkettet mehrere Zeichen, Ziffern oder Sonderzeichen. Er existiert als Objekt in der Klasse java.lang und wird mit der Klasse String erstellt und bearbeitet. Die Programmiersprache bietet Ihnen die Möglichkeit, diese Strings auch in mehrere Teilstrings zu trennen. Die Methode Java String split() wird genutzt, wenn Sie lediglich **bestimmte Bereiche aus dem gesamten String extrahieren** oder diesen in seine **einzelnen Teile zerlegen** möchten. Wir zeigen wir Ihnen die unterschiedlichen Möglichkeiten, die diese Methode bietet.

Wenn Sie Java String split() einsetzen, erhalten Sie ein Array von mehreren Strings zurück. Dieses wird dann zum Rückgabewert.

## Syntax und Funktionsweise der Methode

Die Syntax der Java-Methode String split() ist grundsätzlich sehr einfach, kann allerdings um einen optionalen Parameter erweitert werden. Dies ist zunächst die Basisvariante:

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

Hierbei wird angezeigt, dass die **Rückgabe in Form eines Arrays** passiert. `String` ist das String-Objekt. `regex` ist ein Eingabeparameter, durch den Sie festlegen, an welchen Stellen der String geteilt werden soll. Zwar müssen Sie diesen Parameter nicht zwangsläufig einsetzen, seine Nutzung wird allerdings empfohlen. Mit dem optionalen Parameter `limit` sieht die Syntax aus wie folgt:

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

`limit` gibt an, wie viele Teilstrings erstellt werden sollen. Sein Wert ist ein Integer. Sofern dieser negativ oder gleich 0 ist, werden Ihnen in der Ausgabe alle Teilstrings angezeigt. Wählen Sie einen positiven Wert, werden lediglich entsprechend viele Teilstrings ausgegeben.

## Beispiel für die Methode mit Leerzeichen als Trennzeichen

Am besten verstehen Sie Java String split() aber, wenn Sie seine Nutzung an einem praktischen Beispiel sehen. Hierfür erstellen wir einen String, der aus vier Wörtern besteht: „Dies ist ein Beispiel“. Diesen String können Sie nun mit der Methode aufteilen. Naheliegend ist eine Trennung entlang der bereits vorhandenen Abgrenzungen, die durch die **Leerzeichen zwischen den Wörtern** entstehen. Mit dem folgenden Code führen Sie diese Trennung durch:

```java
public class Main {
	public static void main(String[] args) {
		String x = "Dies ist ein Beispiel";
		String[] ausgabe = x.split(" ");
		for (String y : ausgabe) {
			System.out.println(y);
		}
	}
}
```

Dabei wird nun eine String-Variable x initiiert. Dann wendet Java die String-split()-Methode auf x an. Der Parameter `regex` durchsucht den String auf Leerzeichen und teilt ihn an diesen Stellen. Danach wird das Ergebnis in einem Array namens „ausgabe“ gespeichert. Mit der `for`-Schleife werden diese Teilstrings aufgeführt. Mithilfe des Java-Befehls `System.out.println` erhalten Sie folgende Ausgabe:

```java
Dies
ist
ein
Beispiel
```

## Komma als Trennzeichen: Mit und ohne Leerzeichen

Sie können die Methode auch nutzen, um **Auflistungen zu unterteilen**, die durch Kommata getrennt und so als String abgelegt wurden. Hierbei müssen Sie sich jedoch eines kleinen Tricks bedienen, der auch direkt aufzeigt, wie genau Ihre Anweisungen umgesetzt werden. Stellen wir uns dafür eine Auflistung der Wochentage vor, die jeweils durch Kommata getrennt werden. Diese Kommata wären eigentlich ein guter Parameter, an dem der `regex` ansetzen könnte. Wenn Sie dies so initiieren, sieht der Code folgendermaßen aus:

```java
public class Main {
	public static void main(String[] args) {
		String x = "Montag, Dienstag, Mittwoch, Donnerstag, Freitag, Samstag, Sonntag";
		String[] ausgabe = x.split(",");
		for (String y : ausgabe) {
			System.out.println(y);
		}
	}
}
```

Die Ausgabe wird in diesem Fall nicht ganz ideal ausfallen:

```java
Montag
 Dienstag
 Mittwoch
 Donnerstag
 Freitag
 Samstag
 Sonntag
```

So erhalten Sie zwar ebenfalls eine übersichtliche Auflistung, alle Werte ab „Dienstag“ haben allerdings ein störendes führendes Leerzeichen. Da die Trennung immer direkt nach dem jeweiligen Komma vorgenommen wurde, nimmt Java String split() dieses Leerzeichen als erste Stelle mit in den Teilstring. Wenn Sie dieses kleine Problem umgehen möchten, wandeln Sie die Methode einfach mit einem **zusätzlichen Leerzeichen als Trennzeichen** ab. Dies ist der Code:

```java
public class Main {
	public static void main(String[] args) {
		String x = "Montag, Dienstag, Mittwoch, Donnerstag, Freitag, Samstag, Sonntag";
		String[] ausgabe = x.split(", ");
		for (String y : ausgabe) {
			System.out.println(y);
		}
	}
}
```

Nun ist die Ausgabe viel ordentlicher:

```java
Montag
Dienstag
Mittwoch
Donnerstag
Freitag
Samstag
Sonntag
```

## Ziffernketten trennen

Eine andere Möglichkeit zur Trennung besteht bei langen Ziffernketten. Als Beispiel stellen wir uns einen langen Schlüssel vor, der durch Punkte und einen Doppelpunkt unterteilt ist. Möchten Sie nun die Ziffern **hinter dem Doppelpunkt** gesondert aufführen, ist dies der passende Code:

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

Die Ausgabe sieht dann folgendermaßen aus:

```java
194.518.552.1.17
6339
```

## Die Java-Methode String split() mit dem Parameter limit

Wie erwähnt kennt Java String split() auch den optionalen Parameter `limit`. Dieser begrenzt die Anzahl der Teilstrings, die mit der Methode erstellt werden. Hierbei haben Sie drei Möglichkeiten: ein Wert kleiner als 0, ein Wert gleich 0 oder ein Wert größer als 0.

### limit kleiner als 0

Wählen Sie einen Wert für limit, der kleiner als 0 ist, wird der reguläre Ausdruck **ohne Einschränkung auf die gesamte Zeichenkette angewandt**. Das Array, das dadurch entsteht, kann beliebig lang sein. Der Code sieht beispielhaft so aus:

```java
public class Main {
	public static void main(String[] args) {
		String x = "Montag, Dienstag, Mittwoch, Donnerstag, Freitag, Samstag, Sonntag ";
		String[] ausgabe = x.split(", ", -3);
		for (String y : ausgabe) {
			System.out.println(y);
		}
	}
}
```

Da hinter dem letzten Begriff „Sonntag“ noch ein Leerzeichen ist, endet das Array mit einem leeren String. Die entsprechende Ausgabe ist diese:

```java
Montag
Dienstag
Mittwoch
Donnerstag
Freitag
Samstag
Sonntag
```

### limit 0

Wenn Sie den Wert 0 für den Parameter `limit` wählen, wird der reguläre Ausdruck ebenfalls **so oft wie möglich verwendet**. Auch die Länge des Arrays ist nicht begrenzt. Sollte es sich aber beim letzten Element um einen leeren String handeln, wird dieser für das abschließende Array nicht berücksichtigt.

```java
public class Main {
	public static void main(String[] args) {
		String x = "Montag, Dienstag, Mittwoch, Donnerstag, Freitag, Samstag, Sonntag ";
		String[] ausgabe = x.split(", ", 0);
		for (String y : ausgabe) {
			System.out.println(y);
		}
	}
}
```

Die Ausgabe sieht zwar genauso aus, der letzte String wird in diesem Fall allerdings verworfen:

```java
Montag
Dienstag
Mittwoch
Donnerstag
Freitag
Samstag
Sonntag
```

### limit größer als 0

Offensichtlich sind die Unterschiede, wenn Sie `limit` einen Wert über 0 geben. Dies bestimmt, wie viele Teilstrings ausgegeben werden. Für unser Beispiel sieht das so aus:

```java
public class Main {
	public static void main(String[] args) {
		String x = "Montag, Dienstag, Mittwoch, Donnerstag, Freitag, Samstag, Sonntag ";
		String[] ausgabe = x.split(", ", 3);
		for (String y : ausgabe) {
			System.out.println(y);
		}
	}
}
```

Nun erhalten wir eine Ausgabe, die sich bereits auf den ersten Blick von den beiden Vorgängern unterscheidet:

```java
Montag
Dienstag
Mittwoch, Donnerstag, Freitag, Samstag, Sonntag
```


This is a markdown version of: [https://www.ionos.com/de-ch/digitalguide/websites/web-entwicklung/java-string-split/](https://www.ionos.com/de-ch/digitalguide/websites/web-entwicklung/java-string-split/) for AI/LLM consumption.