# How to split strings in Java

The method `split()` can be used to split strings in Java. It contains a parameter for the separator and an optional parameter for the number of substrings. There are also some particularities to note when using the method. We explain everything you need to know.

## What is `split()`?

[Java strings](https://www.ionos.com/en-ie/digitalguide/websites/web-development/java-strings/) concatenates characters, digits and special characters. They exist as objects in the class java.lang and are created and modified with the String class. In the Java programming language, you can also separate strings into different substrings. Java’s split() is used to **extract certain segments from a string** or to split it into **individual parts**. Below we’ll show you in more detail what you can do with the method.

When splitting a Java string with split(), you’ll get an array with several strings. This becomes the return value.

## What is the syntax of Java’s `split()`?

The basic syntax of Java’s `split()` is very simple, but can be expanded with optional parameters. Here is the basic version:

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

In this example, **the output will be in the form of an array**. `String` is the string object. `regex` is the parameter that’s used to determine where the string should be split. The parameter isn’t required but it is recommended.

The additional optional parameter `limit` allows you to specify how many substrings should be created. Its value is an integer. If it is zero or negative, all substrings will be included in the output. If you choose a positive value, you will get that number of substrings in the output. With the additional optional parameter `limit`, the syntax will look as follows:

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

## How to use `split()` with space as separator

Let’s look at some practical examples. First, we’ll create a string that contains 4 words: ‘This is an example’. Then we’ll split up the string using `split()`. The most intuitive way to split up this string is using the already existing **spaces between the words**. Here’s how that happens in 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 this example, a string variable x is initialised. Then Java’s `split()` is used on the string. The parameter searches the string for spaces and splits it in the places where it finds them. The result is then saved in an array called ‘output’. The `for` loop is used to list the substrings. The Java command `System.out.println` gives us the following output:

```java
This
is
an
example
```

## How to use comma as separator, with and without spaces

You can also use `split()` in Java with strings containing **lists separated by commas**. You’ll just need to use a little trick, because of how precisely your instructions are implemented in Java. First, let’s look at an example without the trick. Say we have a list of the days of the week, separated by commas. These commas make for the perfect separator to enter into `regex`. If we set up the code this way, it will look as follows:

```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 this example, the output isn’t exactly perfect:

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

The output gives us a clear list of the days of the week. However, every value after Sunday contains a space before the day. Since we only used a comma as separator, the spaces were left there in the process of splitting. To get cleaner output, we should use **both a comma and a space** as separator. If we do so, the code will look as follows:

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

The output is now much cleaner:

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

## How to split Java strings with digits

You can also use `split()` to split Java strings made up of digits. In our example, we’ll take a long key that is divided using periods and a colon. If we want to separate the digits **after the colon**, this is what the code would look like:

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

Here’s the output:

```java
194.518.552.1.17
6339
```

## How to use `split()` with the limit parameter

When splitting Java strings with `split()`, you can also use the optional `limit` parameter. The `limit` parameter limits the number of substrings that are created. There are three options here: assigning it a value less than 0, 0 or greater than 0.

### `split()` with a limit less than 0

If you enter a value for `limit` that’s less than 0, the regular expression will be **applied without a limit on the entire string**. The resulting array can be any length. That code might look as follows:

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

Since there is a space after the last word ‘Saturday’, the array will end with an empty string. Here’s the output:

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

### `split()` with a limit of 0

If you set the `limit` parameter to 0, the regular expression will again be used **as many times as possible**. The length of the array isn’t restricted either. But if the last element is an empty string, it won’t be included in the resulting 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);
		}
	}
}
```

The output looks similar to above, but without the final string:

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

### `split()` with a limit greater than 0

The difference becomes more obvious when you set a limit greater than 0. Then it will determine how many substrings can be output.

```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’ll then get an output that’s significantly different from those above:

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


This is a markdown version of: [https://www.ionos.com/en-ie/digitalguide/websites/web-development/string-splitting-in-java/](https://www.ionos.com/en-ie/digitalguide/websites/web-development/string-splitting-in-java/) for AI/LLM consumption.