Concatenating Null Strings in Java

1. Overview

Java provides a variety of methods and classes for concatenating Strings. However, the resultant String may contain some undesirable values if we don’t pay attention to null objects.

In this tutorial, we will see some approaches to avoid null String objects while concatenating Strings.

2. Problem Statement

Let’s say we want to concatenate the elements of a String array where any of the elements may be null.

We can simply do this using the + operator:

String[] values = { "Java ", null, "", "is ", "great!" };
String result = "";

for (String value : values) {
    result = result + value;
}

This will concatenate all the elements into the resultant String, as seen below:

Java nullis great!

But, we may not want to display or append such “null” values to the output.

Similarly, we get the same output using the String.join() static method, if our application is running on Java 8 or higher version:

String result = String.join("", values);

We cannot avoid null elements from being concatenated while using the String.join() method either.

Let’s see some approaches to avoid those null elements from being concatenated and get the result we would expect: “Java is great!”.

3. Using the + Operator

The addition (+) operator is overloaded to concatenate Strings in Java. While concatenating using the + operator, we can check if the String is null, and replace the null String with an empty (“”) String:

for (String value : values) {
    result = result + (value == null ? "" : value);
}

assertEquals("Java is great!", result);

Alternatively, we can extract the code that checks for a null String into a helper method that accepts a String object and returns a non-null String object:

for (String value : values) {
    result = result + getNonNullString(value);
}

Here, getNonNullString() method is our helper method. It simply checks for the null reference of the input String object. If the input object is null, it returns an empty (“”) String, otherwise, it returns the same String:

return value == null ? "" : value;

However, as we know, String objects are immutable in Java. That means, every time we concatenate String objects using the + operator, it creates a new String in memory. So, using the + operator for concatenation turns out to be expensive.

Additionally, we can use this approach of creating a helper method to check for null String objects in various other concatenation supporting operations. Let’s take a look at some of those.

4. Using the String.concat() Method

The String.concat() method is a good choice when we want to concatenate String objects.

Here, we can use our getNonNullString() method that checks for a null object and returns an empty String:

for (String value : values) {
    result = result.concat(getNonNullString(value));
}

The empty String returned by the getNonNullString() method gets concatenated to the result, thus ignoring the null objects.

5. Using the StringBuilder Class

StringBuilder provides a bunch of useful and convenient String building methods. One of those is the append() method.

Here as well, we can use the same getNonNullString() method to avoid null objects while using the append() method:

for (String value : values) {
    result = result.append(getNonNullString(value));
}

6. Using the StringJoiner Class (Java 8+)

The StringJoiner class provides all the functionality of String.join() along with an option to start with a given prefix and end with a given suffix. We can use its add() method to concatenate the Strings.

As before, we can use our helper method getNonNullString() to avoid the null String values from getting concatenated:

StringJoiner result = new StringJoiner("");

for (String value : values) {
    result = result.add(getNonNullString(value));
}

One difference between String.join() and StringJoiner is that unlike String.join(), we have to loop through the collection (Array, List, etc.) to join all the elements.

7. Using Streams.filter (Java 8+)

The Stream API provides a substantial number of sequential and parallel aggregate operations. One such intermediate stream operation is filter which accepts a Predicate as input and transforms the Stream into another Stream based on the given Predicate.

So, we can define a Predicate that will check for the null value of a String and pass this Predicate to the filter() method. Consequently, the filter will filter out those null values from the original Stream.

In the end, we can join all those non-null String values using Collectors.joining() and finally, collect the resultant Stream into a String variable:

result = Stream.of(values).filter(value -> null != value).collect(Collectors.joining(""));

8. Conclusion

In this article, we illustrated various approaches to avoid the concatenation of null String objects. There would always be more than one right approach to meet our requirements. So, we have to determine which approach fits the best at a given place.

We have to keep in mind that concatenating String itself could be an expensive operation, especially in loops. So, it’s always advisable to take into consideration the performance aspects of the Java String API.