Guide to Splitting a String by Whitespace in Java

1. Overview

In Java, a String can be seen as a concatenation of multiple substrings. Moreover, it’s common to use whitespace as a delimiter for building and storing a collection of substrings into a single string.

In this tutorial, we’ll learn how to split a String by whitespace characters, such as space, tab, or newline.

2. What Is Whitespace in Java?

In Java, the concept of whitespace is formally defined by the Character.isWhitespace(char) method. This method returns true for any character that is considered a whitespace character according to the Java language specification.

The most common whitespace characters include, but are not limited to:

The key takeaway is that when we use the \s metacharacter in a regular expression, it matches all the characters listed above, as well as others. This makes it the most robust and concise way to match any whitespace character in Java.

3. String Samples

First, we need to build a few String samples that we can use as input for splitting by whitespace(s). So, let’s start by defining some of the whitespace characters as String constants so that we can reuse them conveniently:

String SPACE = " ";
String TAB = "	";
String NEW_LINE = "\n";

Next, let’s use these as delimiters for defining String samples containing names of different fruits:

String FRUITS_TAB_SEPARATED = "Apple" + TAB + "Banana" + TAB + "Mango" + TAB + "Orange";
String FRUITS_SPACE_SEPARATED = "Apple" + SPACE + "Banana" + SPACE + "Mango" + SPACE + "Orange";
String FRUITS_NEWLINE_SEPARATED = "Apple" + NEW_LINE + "Banana" + NEW_LINE + "Mango" + NEW_LINE + "Orange";

Finally, let’s also write the verifySplit() method that we’ll reuse for verifying the expected result of splitting these strings by whitespace characters:

private void verifySplit(String[] fruitArray) {
    assertEquals(4, fruitArray.length);
    assertEquals("Apple", fruitArray[0]);
    assertEquals("Banana", fruitArray[1]);
    assertEquals("Mango", fruitArray[2]);
    assertEquals("Orange", fruitArray[3]);
}

Now that we’ve built the input strings, we’re ready to explore different strategies to split these and verify the splits.

4. Split Using Delimiter Regex

The split() method of the String class is the de facto standard for splitting strings. It accepts a delimiter regex and produces the splits into an array of Strings:

String[] split(String regex);

First, let’s split the FRUITS_SPACE_SEPARATED String by a single space character:

@Test
public void givenSpaceSeparatedString_whenSplitUsingSpace_shouldGetExpectedResult() {
    String fruits = FRUITS_SPACE_SEPARATED;
    String[] fruitArray = fruits.split(SPACE);
    verifySplit(fruitArray);
}

Similarly, we can split the FRUITS_TAB_SEPARATED and FRUITS_NEWLINE_SEPARATED by using TAB and NEW_LINE, respectively, as the delimiter regex.

Next, let’s try to use a more generic regex for space, tab, and newline characters and split all the string samples with the same regex:

@Test
public void givenWhiteSpaceSeparatedString_whenSplitUsingWhiteSpaceRegex_shouldGetExpectedResult() {
    String whitespaceRegex = SPACE + "|" + TAB + "|" + NEW_LINE;
    String[] allSamples = new String[] { FRUITS_SPACE_SEPARATED, FRUITS_TAB_SEPARATED, FRUITS_NEWLINE_SEPARATED };
    for (String fruits : allSamples) {
        String[] fruitArray = fruits.split(whitespaceRegex);
        verifySplit(fruitArray);
    }
}

So far, it looks like we’ve got this right!

Finally, let’s simplify our approach by using the whitespace meta character (\s) that represents all kinds of whitespace characters by itself:

@Test
public void givenNewlineSeparatedString_whenSplitUsingWhiteSpaceMetaChar_shouldGetExpectedResult() {
    String whitespaceMetaChar = "\\s";
    String[] allSamples = new String[] { FRUITS_SPACE_SEPARATED, FRUITS_TAB_SEPARATED, FRUITS_NEWLINE_SEPARATED };
    for (String fruits : allSamples) {
        String[] fruitArray = fruits.split(whitespaceMetaChar);
        verifySplit(fruitArray);
    }
}

We should note that it’s more convenient and reliable to use the \s meta character over creating our custom regex for whitespace. Further, if our input string can have more than one whitespace character as a delimiter, then we can use \\s+ over \\s without changing the rest of the code.

5. Split Using StringTokenizer

Splitting a string by whitespace is such a common use case that many Java libraries expose an interface to achieve this without specifying the delimiter explicitly. In this section, let’s learn how we can use the StringTokenizer to solve this use case:

@Test
public void givenSpaceSeparatedString_whenSplitUsingStringTokenizer_shouldGetExpectedResult() {
    String fruits = FRUITS_SPACE_SEPARATED;
    StringTokenizer tokenizer = new StringTokenizer(fruits);
    String[] fruitArray = new String[tokenizer.countTokens()];
    int index = 0;
    while (tokenizer.hasMoreTokens()) {
        fruitArray[index++] = tokenizer.nextToken();
    }
    verifySplit(fruitArray);
}

We can see that we didn’t provide any delimiter, as StringTokenizer uses a whitespace delimiter by default. Also, the code follows the iterator design pattern wherein the hasMoreTokens() method decides the loop termination condition, and nextToken() gives the next split.

Further, we should note that we used the countTokens() method to predetermine the number of splits. However, that’s not required if we want to consume the resultant splits one at a time in a sequence. In general, we should use this approach when the input string is long and we want to get the immediate next split without waiting for the entire split process to finish.

6. Split Using Apache Commons

The StringUtils class of the org.apache.commons.lang3 package provides a split() utility method for splitting a String. Like the StringTokenizer class, it uses whitespace as the default delimiter for splitting a string:

public static String[] split(String str);

Let’s start by adding the commons-lang3 dependency in the project’s pom.xml file:

<dependency>
    <groupId>org.apache.commons</groupId>
    <artifactId>commons-lang3</artifactId>
</dependency>

Next, let’s see this in action by splitting the String samples:

@Test
public void givenWhiteSpaceSeparatedString_whenSplitUsingStringUtils_shouldGetExpectedResult() {
    String[] allSamples = new String[] { FRUITS_SPACE_SEPARATED, FRUITS_TAB_SEPARATED, FRUITS_NEWLINE_SEPARATED };
    for (String fruits : allSamples) {
        String[] fruitArray = StringUtils.split(fruits);
        verifySplit(fruitArray);
    }
}

One of the advantages of using the split() utility method of the StringUtils class is that the caller doesn’t have to perform the null checks explicitly. That’s because the split() method handles this gracefully. Let’s continue and see this in action:

@Test
public void givenNullString_whenSplitUsingStringUtils_shouldReturnNull() {
    String fruits = null;
    String[] fruitArray = StringUtils.split(fruits);
    assertNull(fruitArray);
}

As expected, the method returns a null value for null input.

7. Splitting a Text Block

As we’ve explored various string splitting techniques, it’s worth noting that modern Java development often involves working with text blocks. Introduced as a preview feature in Java 15 and standardized in Java 17, text blocks provide a clean way to handle multi-line strings. When dealing with text blocks that contain mixed whitespace characters, the splitting strategies we’ve discussed become particularly valuable.

Let’s consider a practical example where we have a text block containing fruit names separated by different types of whitespace:

@Test
public void givenTextBlockWithMixedWhitespace_whenSplitUsingWhiteSpacePlus_shouldGetExpectedResult() {
    String fruitsTextBlock = """
      Apple Banana
      Mango	Orange
      Guava  Peach
      Cherry   Lime
      """;

    String[] fruitArray = fruitsTextBlock.trim().split("\\s+");

    assertEquals(8, fruitArray.length);
    assertEquals("Apple", fruitArray[0]);
    assertEquals("Banana", fruitArray[1]);
    assertEquals("Mango", fruitArray[2]);
    assertEquals("Orange", fruitArray[3]);
    assertEquals("Guava", fruitArray[4]);
    assertEquals("Peach", fruitArray[5]);
    assertEquals("Cherry", fruitArray[6]);
    assertEquals("Lime", fruitArray[7]);
}

This test showcases how text blocks handle multiple whitespace scenarios commonly found in real-world data:

• Single spaces between “Apple” and “Banana”
• Tab character separating “Mango” and “Orange”
• Multiple spaces between “Guava” and “Peach”
• Varied spacing with triple spaces between “Cherry” and “Lime”
• Newline characters at the end of each line

The combination of trim() and \\s+ proves especially effective here. The trim() method removes any leading or trailing whitespace that might otherwise create empty strings in our result, while \\s+ efficiently handles any sequence of whitespace characters as delimiters, regardless of their specific type or quantity.

Text blocks often contain this kind of mixed whitespace when sourced from configuration files, data exports, or user input, making them ideal for splitting with \\s+ patterns. This consistent approach works across all string types, demonstrating Java’s robust whitespace handling capabilities. The same regex patterns apply universally, whether processing simple strings or complex multi-line text blocks.

8. Conclusion

In this tutorial, we learned multiple approaches for splitting strings by whitespace. Further, we also took note of the advantages and recommended best practices associated with some of the strategies.