Efficiently Joining Array Elements with a Separator in Java

Introduction

In many programming tasks, you might find yourself needing to convert an array of strings into a single string where each element is separated by a specified delimiter. This process is essentially the opposite of splitting a string based on a separator. In this tutorial, we will explore various methods in Java for joining elements of an array or collection with a given separator.

Built-in Method Using String.join

Overview

Starting from Java 8, the String class provides a convenient method named join. This method simplifies the task by eliminating manual iteration and conditional checks. It efficiently joins elements from different data types, including arrays and collections.

Syntax

String joined = String.join(delimiter, elements);

• delimiter: The string that separates each element in the resulting string.
• elements: Can be varargs of CharSequence, an array, or any iterable collection like a list.

Examples

Using Varargs

You can directly pass individual strings to the join method:

String joined1 = String.join(",", "a", "b", "c");
System.out.println(joined1); // Output: "a,b,c"

Using Arrays

Pass an array of strings as follows:

String[] array = {"a", "b", "c"};
String joined2 = String.join(",", array);
System.out.println(joined2); // Output: "a,b,c"

Using Collections

You can also join elements from collections such as lists:

List<String> list = Arrays.asList(array);
String joined3 = String.join(",", list);
System.out.println(joined3); // Output: "a,b,c"

Third-Party Libraries

Guava’s Joiner

Google’s Guava library offers a Joiner class that provides additional flexibility. It allows skipping or replacing null elements and even supports joining maps.

Basic Usage

import com.google.common.base.Joiner;

String[] array = {"a", "b", "c"};
String joined = Joiner.on(",").join(array);
System.out.println(joined); // Output: "a,b,c"

Apache Commons Lang’s StringUtils.join

The Apache Commons Lang library also provides a straightforward method for joining strings.

Example

import org.apache.commons.lang3.StringUtils;

String[] s = {"a", "b", "c"};
String joined = StringUtils.join(s, ",");
System.out.println(joined); // Output: "a,b,c"

Custom Implementation Without External Libraries

If you prefer not to use external libraries, you can implement a custom join method using StringBuilder for efficiency.

Example

public static String strJoin(String[] arr, String sep) {
    StringBuilder sb = new StringBuilder();
    for (int i = 0; i < arr.length; i++) {
        if (i > 0) {
            sb.append(sep);
        }
        sb.append(arr[i]);
    }
    return sb.toString();
}

// Usage
String[] exampleArray = {"a", "b", "c"};
String result = strJoin(exampleArray, ",");
System.out.println(result); // Output: "a,b,c"

This custom method efficiently builds the resulting string using StringBuilder, which is more performant than concatenating strings directly in a loop.

Conclusion

Choosing the right method for joining array elements depends on your project’s needs and constraints. If you are working with Java 8 or later, the built-in String.join method provides a clean and efficient solution. For additional flexibility, consider third-party libraries like Guava or Apache Commons Lang. Alternatively, implementing a custom solution allows full control over the process without external dependencies.