Java 8 Streams | Collectors.joining() method with Examples

09 May, 2022
The joining() method of Collectors Class, in Java, is used to join various elements of a character or string array into a single string object. This method uses the stream to do so. There are various overloads of joining methods present in the Collector class. The class hierarchy is as follows: 
java.lang.Object
  ↳ java.util.stream.Collectors
java.util.stream.Collectors.joining() is the most simple joining method which does not take any parameter. It returns a Collector that joins or concatenates the input streams into String in the order of their appearance.
Syntax:
public static Collector<CharSequence, ?, String> joining()
Illustration: Usage of joining() method
Program 1: Using joining() with an array of characters
In the below program, a character array is created in ‘ch’. Then this array is fed to be converted into Stream using Stream.of(). Then the resulted stream is mapped for a sequential series using map(). At last, the sequential stream containing the character array is joined into a String using Collectors.joining() method. It is stored in the ‘chString’ variable.
Example 
Java
// Java Program to demonstrate the working// of the Collectors.joining() method import java.util.stream.Collectors;import java.util.stream.Stream; // Classpublic class GFG {     // Main driver method    public static void main(String[] args)    {         // Creating a custom character array        char[] ch = { 'G', 'e', 'e', 'k', 's', 'f', 'o',                      'r', 'G', 'e', 'e', 'k', 's' };         // Converting character array into string        // using joining() method of Collectors class        String chString            = Stream.of(ch)                  .map(arr -> new String(arr))                  .collect(Collectors.joining());         // Printing concatenated string        System.out.println(chString);    }}
GeeksforGeeks

Program 2: Using joining() with a list of characters
In the below program, a character list is created in ‘ch’. Then this list is fed to be converted into Stream using ch.stream() method. Then the resulted stream is mapped for a sequential series using map(). At last, the sequential stream containing the character list is joined into a String using Collectors.joining() method. It is stored in ‘chString’ variable. 
Example
Java
// Java Program to demonstrate Working of joining() Method// of Collectors Class // Importing required classesimport java.util.Arrays;import java.util.List;import java.util.stream.Collectors;import java.util.stream.Stream; // Main classpublic class GFG {     // Main driver method    public static void main(String[] args)    {        // Creating a character list        List<Character> ch = Arrays.asList(            'G', 'e', 'e', 'k', 's', 'f', 'o', 'r', 'G',            'e', 'e', 'k', 's');         // Converting character list into string        // using joining() method of Collectors class        String chString            = ch.stream()                  .map(String::valueOf)                  .collect(Collectors.joining());         // Printing the concatenated string        System.out.println(chString);    }}
GeeksforGeeks

Program 3: Using joining() with n list of string
In the below program, a String list is created in ‘str’. Then this list is fed to be converted into Stream using str.stream() method. Then the resulted stream is mapped for a sequential series using map(). At last, the sequential stream containing the character list is joined into a String using Collectors.joining() method. It is stored in ‘chString’ variable. 
Example
Java
// Java Program to demonstrate the working// of the Collectors.joining() method import java.util.Arrays;import java.util.List;import java.util.stream.Collectors;import java.util.stream.Stream; public class GFG {    public static void main(String[] args)    {        // Create a string list        List& lt;        String& gt; str = Arrays.asList("Geeks", "for", "Geeks");         // Convert the string list into String        // using Collectors.joining() method        String chString            = str.stream().collect(Collectors.joining());         // Print the concatenated String        System.out.println(chString);    }}
Output:
GeeksforGeeks
java.util.stream.Collectors.joining(CharSequence delimiter) is an overload of joining() method which takes delimiter as a parameter, of the type CharSequence. A delimiter is a symbol or a CharSequence that is used to separate words from each other. For example, in every sentence, space ‘ ‘ is used as the default delimiter for the words in it. It returns a Collector that joins or concatenates the input elements into String in the order of their appearance, separated by the delimiter. 
Syntax:
public static Collector<CharSequence, ?, String> joining(CharSequence delimiter)
Below are the illustration for how to use joining(delimiter) method: 
Program 1: Using joining(delimiter) with a list of characters: In the below program, a character list is created in ‘ch’. Then this list is fed to be converted into Stream using ch.stream() method. Then the resulted stream is mapped for a sequential series using map(). At last, the sequential stream containing the character list is joined into a String using Collectors.joining() method with “, ” passed as the delimiter. It is stored in ‘chString’ variable. 
Java
// Java Program to demonstrate the working// of the Collectors.joining() method import java.util.Arrays;import java.util.List;import java.util.stream.Collectors;import java.util.stream.Stream; public class GFG {    public static void main(String[] args)    {        // Create a character list        List& lt;        Character& gt;        ch = Arrays.asList('G', 'e', 'e', 'k', 's', 'f',                           'o', 'r', 'G', 'e', 'e', 'k',                           's');         // Convert the character list into String        // using Collectors.joining() method        // with, as the delimiter        String chString = ch.stream()                              .map(String::valueOf)                              .collect(Collectors.joining(                                  ", "));         // Print the concatenated String        System.out.println(chString);    }}
Output:
G, e, e, k, s, f, o, r, G, e, e, k, s
Program 2: Using joining(delimiter) with a list of string: 
In the below program, a String list is created in ‘str’. Then this list is fed to be converted into Stream using str.stream() method. Then the resulted stream is mapped for a sequential series using map(). At last, the sequential stream containing the character list is joined into a String using Collectors.joining() method with “, ” passed as the delimiter. It is stored in ‘chString’ variable. 
Java
// Java Program to demonstrate the working// of the Collectors.joining() method import java.util.Arrays;import java.util.List;import java.util.stream.Collectors;import java.util.stream.Stream; public class GFG {    public static void main(String[] args)    {        // Create a string list        List& lt;        String& gt; str = Arrays.asList("Geeks", "for", "Geeks");         // Convert the string list into String        // using Collectors.joining() method        String chString = str.stream().collect(            Collectors.joining(", "));         // Print the concatenated String        System.out.println(chString);    }}
Output:
Geeks, for, Geeks
java.util.stream.Collectors.joining(CharSequence delimiter, CharSequence prefix, CharSequence suffix) is an overload of joining() method which takes delimiter, prefix and suffix as parameter, of the type CharSequence. A delimiter is a symbol or a CharSequence that is used to separate words from each other. A prefix is a symbol or a CharSequence that is joined at the starting of the 1st element of the String. Then suffix is also a CharSequence parameter but this is joined after the last element of the string. i.e. at the end. For example, in every {Geeks, for, Geeks}, space ‘ ‘ is used as the by default delimiter for the words in it. The ‘{‘ is the prefix and ‘}’ is the suffix. It returns a Collector that joins or concatenates the input elements into String in the order of there appearance, separated by the delimiter. 
Syntax:
public static Collector<CharSequence, ?, String> joining(CharSequence delimiter. 
                                                       CharSequence prefix,
                                                       CharSequence suffix))
Below are the illustration for how to use joining(delimiter, prefix, suffix) method: 
Program 1: Using joining() with a list of characters: In the below program, a character list is created in ‘ch’. Then this list is fed to be converted into Stream using ch.stream() method. Then the resulted stream is mapped for a sequential series using map(). At last, the sequential stream containing the character list is joined into a String using Collectors.joining() method with “, ” passed as the delimiter, “[” as the prefix and “]” as the suffix. It is stored in ‘chString’ variable. 
Java
// Java Program to demonstrate the working// of the Collectors.joining() method import java.util.Arrays;import java.util.List;import java.util.stream.Collectors;import java.util.stream.Stream; public class GFG {    public static void main(String[] args)    {        // Create a character list        List& lt;        Character& gt;        ch = Arrays.asList('G', 'e', 'e', 'k', 's', 'f',                           'o', 'r', 'G', 'e', 'e', 'k',                           's');         // Convert the character list into String        // using Collectors.joining() method        // with, as the delimiter        String chString            = ch.stream()                  .map(String::valueOf)                  .collect(Collectors.joining(                      ", ", "                          [", "] & quot;));         // Print the concatenated String        System.out.println(chString);    }}
Output:
[G, e, e, k, s, f, o, r, G, e, e, k, s]
Program 2: Using joining() with a list of string: In the below program, a String list is created in ‘str’. Then this list is fed to be converted into Stream using str.stream() method. Then the resulted stream is mapped for a sequential series using map(). At last, the sequential stream containing the character list is joined into a String using Collectors.joining() method with “, ” passed as the delimiter, “{” as the prefix and “}” as the suffix. It is stored in ‘chString’ variable. 
Java
// Java Program to demonstrate the working// of the Collectors.joining() method import java.util.Arrays;import java.util.List;import java.util.stream.Collectors;import java.util.stream.Stream; public class GFG {    public static void main(String[] args)    {        // Create a string list        List& lt;        String& gt; str = Arrays.asList("Geeks", "for", "Geeks");         // Convert the string list into String        // using Collectors.joining() method        String chString = str.stream().collect(            Collectors.joining(", ", " {                "                , "            } & quot;));         // Print the concatenated String        System.out.println(chString);    }}
Output:
{Geeks, for, Geeks}
nidhi_biet
ergirishmenghani
Java - util package
Java-Collectors
Java-Functions
Java-Library
java-stream
Java-Stream-Collectors
Java
Java
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Object Oriented Programming (OOPs) Concept in Java
How to iterate any Map in Java
Interfaces in Java
HashMap in Java with Examples
ArrayList in Java
Stream In Java
Collections in Java
Singleton Class in Java
Multidimensional Arrays in Java
Stack Class in Java