Home - News ( United States | United Kingdom | Italy | Germany ) - Football scores

Showing content from https://www.geeksforgeeks.org/java/java-8-streams-collectors-joining-method-with-examples/ below:

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

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 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 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 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

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 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 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

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 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 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}

RetroSearch is an open source project built by @garambo | Open a GitHub Issue

Search and Browse the WWW like it's 1997 | Search results from DuckDuckGo

HTML: 3.2 | Encoding: UTF-8 | Version: 0.7.4