Remove Whitespace From a String in Java

1. Overview

When we manipulate Strings in Java, we often need to remove whitespace from a String.

In this tutorial, we’ll explore common scenarios for removing whitespace from a String in Java.

2. Introduction to the Problem

To understand the problem easier, let’s first see a string example:

String myString = "   I    am a    wonderful String     !   ";

The example above shows that the myString variable contains multiple leading, trailing spaces, and whitespace characters in the middle.

Usually, when we need to deal with a string like myString in Java, we often face these two requirements:

• removing all whitespace characters from the given string -> “IamawonderfulString!”
• replacing consecutive whitespace characters with a single space, and removing all leading and trailing whitespace characters -> “I am a wonderful String !”

Next, we’ll address two approaches for each case: using the handy replaceAll() method from the String class, and the StringUtils class from the widely used Apache Commons Lang3 library.

To keep it simple in this tutorial, we won’t cover whitespace characters in the Unicode character set when we talk about whitespace. Furthermore, we’ll use test assertions to verify each solution.

Now let’s see them in action.

3. Removing All Whitespace From a String

3.1. Using String.replaceAll()

First, we’ll remove all whitespace from a string using the replaceAll() method.

replaceAll() works with regular expressions (regex). We can use the regex character class ‘\s‘ to match a whitespace character. We can replace each whitespace character in the input string with an empty string to solve the problem: inputString.replaceAll(“\\s”, “”).

Then we’ll create a test to see if this idea works with our example string:

String result = myString.replaceAll("\\s", "");
assertThat(result).isEqualTo("IamawonderfulString!");

If we run the test, it passes. So the replaceAll() method solves the problem. Next, let’s solve the problem using Apache Commons Lang3.

3.2. Using the Apache Commons Lang3 Library

The Apache Commons Lang3 library ships with a StringUtils utility, which allows us to manipulate strings conveniently.

To get started using Apache Commons Lang 3, let’s add the Maven dependency:

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

If we check the methods in the StringUtils class, there’s one method called deleteWhitespace(). The name implies that it’s the method we’re looking for.

Next, we’ll remove all whitespace from a string using StringUtils.deleteWhitespace():

String result = StringUtils.deleteWhitespace(myString);
assertThat(result).isEqualTo("IamawonderfulString!");

The test passes when we execute it. So the deleteWhitespace() does the job.

4. Replacing Consecutive Whitespace Characters With One Single Space

4.1. Using String.replaceAll()

Now let’s look at the other scenario. We can solve this problem in two steps:

• replacing consecutive whitespace with one single space
• trimming the result of the first step

It’s worth mentioning that we can also first trim the input string, and then replace consecutive whitespace. So it doesn’t matter which step we take first.

For the first step, we can still use replaceAll() with a regex to match consecutive whitespace characters and set one space as the replacement.

The regex ‘\s+’ matches one or more whitespace characters. Therefore, we can call the replaceAll(“\\s+”, ” “) method to finish the first step. Then we can invoke the String.trim() method to apply the trim operation.

Next, we’ll create a test to check if our idea can solve the problem. To make it clear, we write two assertions for the two steps:

String result = myString.replaceAll("\\s+", " ");
assertThat(result).isEqualTo(" I am a wonderful String ! ");
assertThat(result.trim()).isEqualTo("I am a wonderful String !");

If we run it, the test passes. So the approach works as expected.

Finally, let’s solve the problem using the Apache Commons Lang 3 library.

4.2. Using the Apache Commons Lang3 Library

The StringUtils.normalizeSpace() method trims the input string and then replaces sequences of whitespace characters with a single space. Therefore, we can directly call this method to solve the problem:

String result = StringUtils.normalizeSpace(myString);
assertThat(result).isEqualTo("I am a wonderful String !");

The test passes when we execute it. As we can see, StringUtils.normalizeSpace() is pretty straightforward to use.

5. Remove Only Leading and Trailing Whitespace

5.1. Using strip()

The strip() method is used to remove leading and trailing whitespace from a string. This method was introduced in Java 11 and is more Unicode-aware than the older trim() method, which only removes the standard ASCII whitespace characters.

Let’s see how we can use this method to remove leading and trailing whitespace from a string:

String result = myString.strip();
assertThat(result).isEqualTo("I am a wonderful String !");

In this example, strip() removes only the leading and trailing whitespace. It doesn’t remove whitespace within the string.

5.2. Using stripLeading() and stripTrailing()

Java 11 also introduced stripLeading() and stripTrailing() methods to remove whitespace only from the beginning or end of the string, respectively:

String result = myString.stripLeading();
assertThat(result).isEqualTo("I am a wonderful String !   ");

String result = myString.stripTrailing();
assertThat(result).isEqualTo("   I am a wonderful String !");

In the above code example, we remove the leading and trailing whitespaces using stripLeading() and stripTrailing() methods.

6. Conclusion

In this article, we learned how to remove whitespace characters from a string in Java.