Java 8 – Join List Elements into a String

Introduction

Joining elements of a list into a single string is a common task in Java, especially when you need to create a comma-separated list or a formatted string from a collection of elements. Java 8 introduced the Stream API, which makes this task much simpler and more efficient. In this guide, we’ll explore how to join list elements into a string using Java 8 Streams, covering various use cases including joining with different delimiters, prefixes, and suffixes.

Table of Contents

• Problem Statement
• Solution Steps
• Java Program
  • Joining a List of Strings with a Comma
  • Joining a List of Integers with a Custom Delimiter
  • Joining a List of Custom Objects into a String
• Advanced Considerations
• Conclusion

Problem Statement

The task is to create a Java program that:

• Accepts a list of elements.
• Joins the elements into a single string.
• Outputs the resulting string.

Example 1:

• Input: List of strings ["apple", "banana", "orange"], join with a comma.
• Output: "apple, banana, orange"

Example 2:

• Input: List of integers [1, 2, 3], join with a hyphen.
• Output: "1-2-3"

Solution Steps

1. Input List: Start with a list of elements that can either be hardcoded or provided by the user.
2. Join Elements Using Streams: Use the Collectors.joining() method to join the elements into a string.
3. Display the Result: Print the resulting string.

Java Program

Joining a List of Strings with a Comma

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

/**
 * Java 8 - Join List of Strings into a Single String Using Streams
 * Author: https://www.rameshfadatare.com/
 */
public class JoinListStrings {

    public static void main(String[] args) {
        // Step 1: Take input list
        List<String> fruits = Arrays.asList("apple", "banana", "orange");

        // Step 2: Join the list elements with a comma
        String result = fruits.stream()
                              .collect(Collectors.joining(", "));

        // Step 3: Display the result
        System.out.println("Joined string: " + result);
    }
}

Output

Joined string: apple, banana, orange

Explanation

• The stream() method is used to create a stream from the list of strings.
• The Collectors.joining(", ") method joins the elements with a comma and a space.
• The resulting string is "apple, banana, orange", which is printed to the console.

Joining a List of Integers with a Custom Delimiter

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

/**
 * Java 8 - Join List of Integers into a Single String with a Custom Delimiter
 * Author: https://www.rameshfadatare.com/
 */
public class JoinListIntegers {

    public static void main(String[] args) {
        // Step 1: Take input list
        List<Integer> numbers = Arrays.asList(1, 2, 3);

        // Step 2: Join the list elements with a hyphen
        String result = numbers.stream()
                               .map(String::valueOf)  // Convert Integer to String
                               .collect(Collectors.joining("-"));

        // Step 3: Display the result
        System.out.println("Joined string: " + result);
    }
}

Output

Joined string: 1-2-3

Explanation

• The stream() method is used to create a stream from the list of integers.
• The map(String::valueOf) method converts each integer to a string.
• The Collectors.joining("-") method joins the elements with a hyphen.
• The resulting string is "1-2-3", which is printed to the console.

Joining a List of Custom Objects into a String

import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

/**
 * Java 8 - Join List of Custom Objects into a Single String
 * Author: https://www.rameshfadatare.com/
 */
public class JoinListCustomObjects {

    public static void main(String[] args) {
        // Step 1: Take input list of custom objects
        List<Student> students = Arrays.asList(
                new Student("Raj", 25),
                new Student("Anita", 30),
                new Student("Vikram", 22)
        );

        // Step 2: Join the list elements into a single string
        String result = students.stream()
                                .map(student -> student.getName() + ": " + student.getAge())
                                .collect(Collectors.joining(", "));

        // Step 3: Display the result
        System.out.println("Joined string: " + result);
    }
}

// Custom class Student
class Student {
    private String name;
    private int age;

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

Output

Joined string: Raj: 25, Anita: 30, Vikram: 22

Explanation

• The stream() method is used to create a stream from the list of Student objects.
• The map() method formats each Student object into a string combining the name and age.
• The Collectors.joining(", ") method joins the formatted strings with a comma and a space.
• The resulting string is "Raj: 25, Anita: 30, Vikram: 22", which is printed to the console.

Advanced Considerations

• Custom Delimiters, Prefixes, and Suffixes: The Collectors.joining() method also allows you to specify a prefix and suffix along with the delimiter. For example:

  String result = fruits.stream()
                        .collect(Collectors.joining(", ", "[", "]"));
  

  This would result in the output "[apple, banana, orange]".

• Null Handling: When joining elements, consider how you want to handle null values. You might filter out nulls before joining:

  String result = list.stream()
                      .filter(Objects::nonNull)
                      .collect(Collectors.joining(", "));
  

• Performance Considerations: Joining elements using Streams is efficient for typical list sizes. However, for very large lists, consider testing performance and memory usage, especially when the list is made up of large objects or strings.

Conclusion

This guide provides methods for joining list elements into a string using Java 8 Streams, covering both simple lists like strings and integers, as well as more complex lists like custom objects. Java 8 Streams offer a powerful and flexible way to perform this operation, making your code more readable and maintainable. Depending on your specific use case, you can easily apply the techniques demonstrated in this guide to join list elements into a single, formatted string.