Java 8 Streams | Collectors.joining() method with Examples
Last Updated :
17 Jan, 2023
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
joining()
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;
// Class
public 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);
}
}
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 classes
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;
import java.util.stream.Stream;
// Main class
public 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);
}
}
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<String> 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
joining(delimiter)
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<Character> 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<String> 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
joining(delimiter, prefix, suffix)
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 their 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<Character> 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() 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<String> 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}
Similar Reads
Collectors toList() method in Java with Examples
The toList() method of Collectors Class is a static (class) method. It returns a Collector Interface that gathers the input data onto a new list. This method never guarantees type, mutability, serializability, or thread-safety of the returned list but for more control toCollection(Supplier) method c
2 min read
Java streams counting() method with examples
In Java 8, there is predefined counting() method returned by Collectors class counting() method to count the number of elements in a Stream. Syntax : public static Collector counting() Where, output is a Collector, acting on a Stream of elements of type T, with its finisher returning the ‘collected’
2 min read
Stream count() method in Java with examples
long count() returns the count of elements in the stream. This is a special case of a reduction (A reduction operation takes a sequence of input elements and combines them into a single summary result by repeated application of a combining operation). This is a terminal operation i.e, it may travers
2 min read
Collections list() method in Java with Examples
The list() method of java.util.Collections class is used to return an array list containing the elements returned by the specified enumeration in the order they are returned by the enumeration. This method provides interoperability between legacy APIs that return enumerations and new APIs that requi
2 min read
Collectors toSet() in Java with Examples
Collectors toSet() returns a Collector that accumulates the input elements into a new Set. There are no guarantees on the type, mutability, serializability, or thread-safety of the Set returned. This is an unordered Collector i.e, the collection operation does not commit to preserving the encounter
2 min read
Stream dropWhile() method in Java with examples
The dropWhile(java.util.function.Predicate) method returns two different types of stream depending upon whether the stream is ordered or not. If the stream is ordered then a stream of the remaining elements of this stream after dropping the longest prefix of elements that match the given predicate i
3 min read
Java String Class lines() Method with Examples
lines() method is a static method which returns out stream of lines extracted from a given multi-line string, separated by line terminators which are as follows: Line terminators Command Line feed character\nA carriage return character\rA carriage return followed immediately by a line feed\r\n Synta
3 min read
BitSet stream() Method in Java with Examples
The stream() method of Java BitSet class is used to return a stream of indices for every bit contained in the BitSet. The indices are returned in increasing order. The size of the stream is the number of bits in the set state of the BitSet, which is equal to the value returned by the cardinality() m
2 min read
Collections synchronizedMap() method in Java with Examples
The synchronizedMap() method of java.util.Collections class is used to return a synchronized (thread-safe) map backed by the specified map. In order to guarantee serial access, it is critical that all access to the backing map is accomplished through the returned map. Syntax: public static <K, V
2 min read
Collections synchronizedSet() method in Java with Examples
The synchronizedSet() method of java.util.Collections class is used to return a synchronized (thread-safe) set backed by the specified set. In order to guarantee serial access, it is critical that all access to the backing set is accomplished through the returned set. Syntax: public static <T>
2 min read