Join Array of Primitives with Separator in Java

1. Introduction

In this quick tutorial, we’ll learn how to join an array of primitives with a single-character separator in Java. For our examples, we’ll consider two arrays: an array of int and an array of char.

2. Defining the Problem

Let’s start by defining an array of int and an array of char for the examples, as well as the separator character we’ll use to join their contents:

int[] intArray = {1, 2, 3, 4, 5, 6, 7, 8, 9};
char[] charArray = {'a', 'b', 'c', 'd', 'e', 'f'};
char separatorChar = '-';
String separator = String.valueOf(separatorChar);

Note that we’ve included both a char and String separator since some of the methods we’ll show require a char argument, while others require a String argument.

The results of the joining operation will contain “1-2-3-4-5-6-7-8-9” for the int array, and “a-b-c-d-e-f” for the char array.

3. Collectors.joining()

Let’s start with one of the available methods from the  Java 8 Stream API — Collectors.joining().

First, we create a Stream from an array of primitives using the Arrays.stream() method found in the java.util package. Next, we map each element to String. And finally, we concatenate the elements with our given separator.

Let’s begin with our int array:

String joined = Arrays.stream(intArray)
  .mapToObj(String::valueOf)
  .collect(Collectors.joining(separator));

When joining our char array with this method, we must first wrap the char array into CharBuffer and then project it to char again. This is because the chars() method returns a Stream of int values.

Unfortunately, the Java Stream API does not provide a native method for wrapping a Stream of char.

Let’s join our char array:

String joined = CharBuffer.wrap(charArray).chars()
  .mapToObj(intValue -> String.valueOf((char) intValue))
  .collect(Collectors.joining(separator));

4. StringJoiner

Similarly to Collectors.joining(), this approach makes use of the Stream API, but instead of collecting elements, it iterates through elements and adds them to a StringJoiner instance:

StringJoiner intStringJoiner = new StringJoiner(separator);
Arrays.stream(intArray)
  .mapToObj(String::valueOf)
  .forEach(intStringJoiner::add);
String joined = intStringJoiner.toString();

Again, we have to wrap our char array into CharBuffer when using the Stream API:

StringJoiner charStringJoiner = new StringJoiner(separator);
CharBuffer.wrap(charArray).chars()
  .mapToObj(intChar -> String.valueOf((char) intChar))
  .forEach(charStringJoiner::add);
String joined = charStringJoiner.toString();

5. Apache Commons Lang

The Apache Commons Lang library provides some handy methods in the StringUtils and ArrayUtils classes that we can use to join our primitive arrays.

To use this library, we’ll need to add the commons-lang3 dependency to our pom.xml:

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

When working with a String separator, we’ll make use of both StringUtils and ArrayUtils.

Let’s use these together to join our int array:

String joined = StringUtils.join(ArrayUtils.toObject(intArray), separator);

Or, if we’re using a primitive char type as a separator, we can simply write:

String joined = StringUtils.join(intArray, separatorChar);

The implementations for joining our char array are quite similar:

String joined = StringUtils.join(ArrayUtils.toObject(charArray), separator);

And when using a char separator:

String joined = StringUtils.join(charArray, separatorChar);

6. Guava

Google’s Guava library provides the Joiner class that we can use to join our arrays. To use Guava in our project, we’ll need to add the guava Maven dependency:

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

Let’s join our int array using the Joiner class:

String joined = Joiner.on(separator).join(Ints.asList(intArray));

In this example, we also used the Ints.asList() method from Guava, which nicely transforms the array of primitives into a List of Integer.

Guava offers a similar method for converting a char array to a List of Character. As a result, joining our char array looks very much like the above example that used the int array:

String joined = Joiner.on(separator).join(Chars.asList(charArray));

7. StringBuilder

Finally, if we can’t use either Java 8 or third-party libraries, we can manually join an array of elements with StringBuilder. In this case, the implementation is identical for both types of arrays:

if (array.length == 0) {
    return "";
}
StringBuilder stringBuilder = new StringBuilder();
for (int i = 0; i < array.length - 1; i++) {
    stringBuilder.append(array[i]);
    stringBuilder.append(separator);
}
stringBuilder.append(array[array.length - 1]);
String joined = stringBuilder.toString();

8. Conclusion

This quick article illustrates a number of ways to join an array of primitives with a given separator character or string. We showed examples using native JDK solutions, as well as additional solutions using two third-party libraries — Apache Commons Lang and Guava.

As always, the complete code used in this article is available over on GitHub.