Convert a List to a Comma-Separated String

1. Introduction

List conversion is still a hot topic as it’s something that we do very often as Java developers. In this tutorial, we’ll learn how to convert a List of String to a comma-separated String using four different approaches.

2. Using Java 8+

We’ll use three different classes and their methods, available since Java 8, for conversion.

Let’s take the following list as input for the upcoming examples:

List<String> arraysAsList = Arrays.asList("ONE", "TWO", "THREE");

2.1. String

First, we’ll use the String class, which has many utilities for String processing and provides the conversion method join():

String commaSeparatedString = String.join(",", arraysAsList);

assertThat(commaSeparatedString).isEqualTo("ONE,TWO,THREE");

2.2. StringJoiner

Second, we’ll use the StringJoiner class, which has a constructor that accepts a CharSequence delimiter as a parameter:

StringJoiner stringJoiner = new StringJoiner(",");
arraysAsList.forEach(stringJoiner::add);
String commaSeparatedString = stringJoiner.toString();

assertThat(commaSeparatedString).isEqualTo("ONE,TWO,THREE");

There’s another constructor which takes a CharSequence delimiter, a CharSequence as a prefix, and another as a suffix:

StringJoiner stringJoinerWithDelimiterPrefixSuffix = new StringJoiner(",", "[", "]");
arraysAsList.forEach(stringJoinerWithDelimiterPrefixSuffix::add);
String commaSeparatedStringWithDelimiterPrefixSuffix = stringJoinerWithDelimiterPrefixSuffix.toString();

assertThat(commaSeparatedStringWithDelimiterPrefixSuffix).isEqualTo("[ONE,TWO,THREE]");

2.3. Collectors

Third, the Collectors class provides various utility and joining() methods with different signatures.

Firstly let’s have a look at how to apply to a Stream the collect() method by using the Collectors.joining() method, which takes as input a CharSequence delimiter:

String commaSeparatedUsingCollect = arraysAsList.stream()
  .collect(Collectors.joining(","));

assertThat(commaSeparatedUsingCollect).isEqualTo("ONE,TWO,THREE");

In our next example, we’ll see how to use the map() method to convert each object of the list into a String and then apply the methods collect() and Collectors.joining():

String commaSeparatedObjectToString = arraysAsList.stream()
  .map(Object::toString)
  .collect(Collectors.joining(","));

assertThat(commaSeparatedObjectToString).isEqualTo("ONE,TWO,THREE");

Next, we’ll use the map() method to convert the list elements into a String and then apply the methods collect() and Collectors.joining():

String commaSeparatedStringValueOf = arraysAsList.stream()
  .map(String::valueOf)
  .collect(Collectors.joining(","));

assertThat(commaSeparatedStringValueOf).isEqualTo("ONE,TWO,THREE");

Now, let’s use map() as above, then the Collectors.joining() method that inputs a CharSequence delimiter, a CharSequence as a prefix, and a CharSequence as a suffix:

String commaSeparatedStringValueOfWithDelimiterPrefixSuffix = arraysAsList.stream()
  .map(String::valueOf)
  .collect(Collectors.joining(",", "[", "]"));

assertThat(commaSeparatedStringValueOfWithDelimiterPrefixSuffix).isEqualTo("[ONE,TWO,THREE]");

Lastly, we’ll see how to use the reduce() method to convert the list instead of the collect():

String commaSeparatedUsingReduce = arraysAsList.stream()
  .reduce((x, y) -> x + "," + y)
  .get();

assertThat(commaSeparatedUsingReduce).isEqualTo("ONE,TWO,THREE");

3. Using Apache Commons Lang

Alternatively, we can also use the utility classes provided by the Apache Commons Lang library instead of the Java ones.

We must add a dependency to our pom.xml file to use Apache’s StringUtils class:

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

The join() method has various implementations that accept inputs like a series of elements, an Iterator of values, also a delimiter under multiple forms such as String or char:

String commaSeparatedString = StringUtils.join(arraysAsList, ",");

assertThat(commaSeparatedString).isEqualTo("ONE,TWO,THREE");

If the information passed to join() is an array of Object, it also takes an int as startIndex and an int as endIndex:

String commaSeparatedStringIndex = StringUtils.join(arraysAsList.toArray(), ",", 0, 3);

assertThat(commaSeparatedStringIndex).isEqualTo("ONE,TWO,THREE");

4. Using Spring Core

Spring Core library similarly provides a utility class having methods for this type of conversion.

We first add a dependency to our pom.xml file to use Spring’s Core StringUtils class:

<dependency>
    <groupId>org.springframework</groupId>
    <artifactId>spring-core</artifactId>
    <version>5.3.22</version>
</dependency>

Spring’s Core StringUtils class provides a method, collectionToCommaDelimitedString(), which takes a comma as the default delimiter and a Collection to convert as a parameter:

String collectionToCommaDelimitedString = StringUtils.collectionToCommaDelimitedString(arraysAsList);

assertThat(collectionToCommaDelimitedString).isEqualTo("ONE,TWO,THREE");

A second method, collectionToDelimitedString(), takes as parameters a Collection to convert and a String delimiter:

String collectionToDelimitedString = StringUtils.collectionToDelimitedString(arraysAsList, ",");

assertThat(collectionToDelimitedString).isEqualTo("ONE,TWO,THREE");

5. Using Google Guava

Lastly, we’ll use the Google Guava library.

We must add a dependency to our pom.xml file to use Google’s Guava Joiner class:

<dependency>
    <groupId>com.google.guava</groupId>
    <artifactId>guava</artifactId>
    <version>31.1-jre</version>
</dependency>

Google’s Guava Joiner class provides various methods we can apply consequently.

The first method is on(), which takes as a delimiter parameter a String, and then the second method is the join() method which takes as a parameter the Iterable having the values to convert:

String commaSeparatedString = Joiner.on(",")
  .join(arraysAsList);

assertThat(commaSeparatedString).isEqualTo("ONE,TWO,THREE");

Let’s take another list containing some null values for the next example:

List<String> arraysAsListWithNull = Arrays.asList("ONE", null, "TWO", null, "THREE");

Given that, we can use other methods between the on() and join(), and one of these is the skipNulls() method. We can use it to avoid the conversion of the null values from inside the Iterable:

String commaSeparatedStringSkipNulls = Joiner.on(",")
  .skipNulls()
  .join(arraysAsListWithNull);

assertThat(commaSeparatedStringSkipNulls).isEqualTo("ONE,TWO,THREE");

Another option is to use useForNull(), which takes a String value as a parameter to substitute the null values inside the Iterable to convert:

String commaSeparatedStringUseForNull = Joiner.on(",")
  .useForNull(" ")
  .join(arraysAsListWithNull);

assertThat(commaSeparatedStringUseForNull).isEqualTo("ONE, ,TWO, ,THREE");

6. Conclusion

In this article, we’ve seen various examples of converting a List of String to a comma-separated String. Finally, it’s up to us to choose which library and utility classes fit better for our purpose.

As always, the complete code samples for this article can be found over on GitHub.