StringJoiner Class vs String.join() Method to Join String in Java with Examples - GeeksforGeeks

05 Feb, 2021
Prior to Java 8 when we need to concatenate a group of strings we need to write that code manually in addition to this we needed to repeatedly use delimiter and sometimes it leads to several mistakes but after Java 8 we can concatenate the strings using StringJoiner class and String.join() method then we can easily achieve our goal.
Example: Without StringJoiner Class and without String.join() method
Approach :
In this program we will not use java 8 we will try to do it manually and try to understand for this simple operation of the concatenation of strings with delimiter how much bigger code/steps we needed to achieve our goal.
First, we will join three strings “DSA”, “FAANG”, “ALGO”, and the delimiter will be “gfg” for doing this we need to write delimiter every time before adding the next string.
Next, we will join elements of an ArrayList containing strings “DSA”,”FAANG”, “ALGO” and delimiter will be ” gfg ” and for doing this we needed to iterate over ArrayList and then add strings using a delimiter.
Note here for i=0 we directly assigned the string joined2 to the first element of ArrayList because if we didn’t put this condition then we will get the output like this ” gfg DSA gfg FAANG gfg ALGO” whereas the actual output did not have a delimiter before the first element of ArrayList “DSA gfg FAANG gfg ALGO”.
As from the code you can see how much code is written for doing this simple task for doing task now we will look for using StringJoiner class and String.join() method.
Java
// Java program for joining the strings before Java8// by simple method using '+' to concatenate   import java.io.*;import java.util.ArrayList;import java.util.Arrays;  class GFG {    public static void main(String[] args)    {        // Here we need to join strings "DSA","FAANG","ALGO"        // and with delimiter " gfg "        String joined = "DSA"                        + " gfg "                        + "FAANG"                        + " gfg "                        + "ALGO";          // Here we created an ArrayList of strings        // ArrayList contains "DSA","FAANG","ALGO"        ArrayList<String> gfgstrings = new ArrayList<>(            Arrays.asList("DSA", "FAANG", "ALGO"));                String joined2 = "";                // Now we will iterate over ArrayList        for (int i = 0; i < gfgstrings.size(); i++) {                        // for i== 0 we do not want to add space before            // first word thats why we checked for i=0            if (i == 0) {                joined2 = gfgstrings.get(i);            }              else {                joined2                    = joined2 + " gfg " + gfgstrings.get(i);            }        }                // printing the first output        System.out.println(joined);        System.out.println("--------------------");                // printing the second output        System.out.println(joined2);    }}
DSA gfg FAANG gfg ALGO
--------------------
DSA gfg FAANG gfg ALGO
StringJoiner Class :
StringJoiner is used to construct a sequence of characters separated by a delimiter and optionally starting with a supplied prefix and ending with a supplied suffix. In simple words in the constructor of StringJoiner calls we can pass Three parameters delimiter, suffix, prefix. Prefix be added to the start of a String and suffix will be at the end. For adding the strings we will need to simply call the add() method on the StringJoiner class.
Syntax :
If we have suffix and prefix
StringJoiner joined=StringJoiner(delimiter,prefix,suffix)

joined.add(string1);
joined.add(string2);
joined.add(string3);
If we don’t have suffix and prefix
StringJoiner joined=StringJoiner(delimiter)

joined.add(string1);
joined.add(string2);
joined.add(string3);
Approach:
If you are adding a group of strings you need to create StringJoiner class Object and pass delimiter, prefix, suffix.
Here the delimiter is “gfg ” string and the prefix is “[” and suffix is “]”. Now we need to add strings in StringJoiner class using add() method.
Finally, we will convert the StringJoiner object to a String object using toString() method.
In case we have ArrayList of strings the delimiter is “gfg ” and prefix is “[” and suffix is “]” and we will iterate over the Arraylist and elements in StringJoiner and then convert into String object.
Finally, we will print the output.
Program of joining Strings using StringJoiner class :
Java
// Java program for joining the strings// Using StringJoiner class  import java.io.*;import java.util.ArrayList;import java.util.Arrays;import java.util.StringJoiner;  class GFG {    public static void main(String[] args)    {        // Here we need to join strings "DSA","FAANG","ALGO"        // and with delimiter " gfg "        StringJoiner sj            = new StringJoiner(" gfg ", "[", "]");                sj.add("DSA");        sj.add("FAANG");        sj.add("ALGO");                // Convert StringJoiner to String        String joined = sj.toString();          // Here we created an ArrayList of strings        ArrayList<String> gfgstrings = new ArrayList<>(            Arrays.asList("DSA", "FAANG", "ALGO"));                // StringJoiner class having parameters        // delimiter,prefix,suffix        StringJoiner sj2            = new StringJoiner(" gfg ", "[", "]");                // Now we will iterate over ArrayList        // and adding in string Joiner class        for (String arl : gfgstrings) {            sj2.add(arl);        }                // convert StringJoiner object to String        String joined2 = sj2.toString();          // printing the first output        System.out.println(joined);        System.out.println("--------------------");                // printing the second output        System.out.println(joined2);    }}
[DSA gfg FAANG gfg ALGO]
--------------------
[DSA gfg FAANG gfg ALGO]
String.join():
The java.lang.string.join() method concatenates the given element with the delimiter and returns the concatenated string. Note that if an element is null, then null is added. The join() method was introduced in java string since JDK 1.8. String.join() method takes two parameters first is a delimiter and the second can be a list or array of elements or elements separated by ,(comma).
Syntax :
In the case of individual elements
String joined=String.join("delimiter","element1","element2,"element3"...);
In the case of List
String joined2=String.join("delimiter",listObject);
Return Type: It returns the string joined by using of delimiter
Example:
Approach:  Joining strings using String.join() method
In this example for the individual string, we need to pass the delimiter and strings in join() method. Here delimiter is ” gfg ” and strings are “DSA”, “FAANG”, “ALGO”.
String.join() will return the string joined using a delimiter.
For ArrayList, we need to simply pass the delimiter and list object in join method join(” gfg “,listObject) this will return the string joined using delimiter on each element of ArrayList.
Java
// Java program for joining the strings// Using String.join() method  import java.io.*;import java.util.ArrayList;import java.util.Arrays;import java.util.StringJoiner;  class GFG {    public static void main(String[] args)    {        // Here we need to join strings "DSA","FAANG","ALGO"        // and with delimiter " gfg "          String joined            = String.join(" gfg ", "DSA", "FAANG", "ALGO");          // Here we created an ArrayList of strings        ArrayList<String> gfgstrings = new ArrayList<>(            Arrays.asList("DSA", "FAANG", "ALGO"));                String joined2 = String.join(" gfg ", gfgstrings);          // printing the first output        System.out.println(joined);                System.out.println("--------------------");                // printing the second output        System.out.println(joined2);    }}
DSA gfg FAANG gfg ALGO
--------------------
DSA gfg FAANG gfg ALGO
Java-StringJoiner
Java-Strings
Picked
Difference Between
Java
Java-Strings
Java
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.
Difference between var, let and const keywords in JavaScript
Difference Between Method Overloading and Method Overriding in Java
Difference between Prim's and Kruskal's algorithm for MST
Difference between Internal and External fragmentation
Difference between Compile-time and Run-time Polymorphism in Java
Arrays in Java
Split() String method in Java with examples
For-each loop in Java
Object Oriented Programming (OOPs) Concept in Java
Arrays.sort() in Java with examples