Extract the email addresses of all employees and return as a comma-separated string using Collectors.joining(", ")

• Collectors.joining(delimiter) concatenates a stream of strings with the given separator between each pair.
• Three overloads: no-arg (plain concat), one-arg (delimiter), three-arg (delimiter, prefix, suffix).
• Internally uses StringJoiner, which appends to a single buffer for O(n) performance.
• No trailing delimiter: the separator appears only between elements, not at the start or end.
• Requires Stream: you must map to strings first.

What does Collectors.joining do?

First you project each employee to its email with map(Employee::getEmail), producing a stream of email strings. Then the terminal collector Collectors.joining(", ") concatenates them into a single string, inserting the delimiter between consecutive elements but not at the very start or very end.

How do you extract emails as a comma-separated string?

package com.bank.hr;

import java.math.BigDecimal;
import java.util.List;
import java.util.stream.Collectors;

public class JoiningEmails {
    public static void main(String[] args) {
        List<Employee> staff = List.of(
            new Employee("Rajesh",  "rajesh@nbi.com",  "Loans",   new BigDecimal("95000")),
            new Employee("Priya",   "priya@nbi.com",   "IT",      new BigDecimal("120000")),
            new Employee("Amit",    "amit@nbi.com",    "Finance", new BigDecimal("85000")));

        String emailList = staff.stream()
            .map(Employee::getEmail)
            .collect(Collectors.joining(", "));

        System.out.println(emailList);
    }
}

rajesh@nbi.com, priya@nbi.com, amit@nbi.com

What are the three overloads of joining?

| Overload | Example | Result |
|---|---|---|
| joining() | joining() | "rajesh@nbi.compriya@nbi.comamit@nbi.com" |
| joining(delimiter) | joining(", ") | "rajesh@nbi.com, priya@nbi.com, amit@nbi.com" |
| joining(delim, prefix, suffix) | joining(", ", "[", "]") | "[rajesh@nbi.com, priya@nbi.com, amit@nbi.com]" |

// Bracketed list for a summary report
String bracketed = staff.stream()
    .map(Employee::getEmail)
    .collect(Collectors.joining(", ", "[", "]"));

System.out.println(bracketed);
// [rajesh@nbi.com, priya@nbi.com, amit@nbi.com]

What are common mistakes?

Mistake: a null email in the stream throws NullPointerException during concatenation.

// WRONG: if any email is null, joining crashes
String emails = staff.stream()
    .map(Employee::getEmail)  // might return null
    .collect(Collectors.joining(", ")); // NPE!

// CORRECT: filter out nulls first
String emails = staff.stream()
    .map(Employee::getEmail)
    .filter(java.util.Objects::nonNull)
    .collect(Collectors.joining(", "));

How is joining different from reduce for string concatenation?

| Approach | Performance | Simplicity |
|---|---|---|
| Collectors.joining(", ") | O(n) via StringJoiner | One line, clean |
| reduce("", (a, b) -> a + ", " + b) | O(n^2) via String copies | Bug-prone (leading comma) |

// Joining: O(n), clean, no leading-comma bug
staff.stream().map(Employee::getEmail)
    .collect(Collectors.joining(", "));

// Reduce: O(n^2), must guard leading comma manually
staff.stream().map(Employee::getEmail)
    .reduce("", (a, b) -> a.isEmpty() ? b : a + ", " + b);

What about joining non-string types?

joinig only works on Stream. For non-string types, map to a string representation first.

// Joining salary amounts as a string
String salaries = staff.stream()
    .map(e -> e.getSalary().toPlainString())
    .collect(Collectors.joining(" | "));

System.out.println(salaries);
// 95000 | 120000 | 85000

What should a senior engineer know?

• Under the hood, joining uses a StringJoiner, which is efficient because it appends to a single growing buffer rather than creating a new string for each concatenation.
• For very large datasets, the resulting string could be huge; consider streaming output instead of building one giant string.
• joining is the idiomatic and efficient way to build delimited strings; never use reduce with string concatenation in production.

What are common interview follow-up questions?

• "What happens if the stream is empty?" joining returns an empty string (or just prefix+suffix for the three-arg form).
• "Why not use reduce for string concatenation?" It is O(n^2) because each + creates a new String.
• "Can you add a prefix and suffix?" Yes, use the three-argument joining(delimiter, prefix, suffix).