Java StringJoiner

Java StringJoiner is a class introduced in Java 8 that provides a way to join strings with a delimiter and optional prefix and suffix. It is a convenient and efficient alternative to using a StringBuilder or StringBuffer to manually append strings with delimiters.

The StringJoiner class provides three constructors:

1. StringJoiner(CharSequence delimiter): Creates a new StringJoiner with the specified delimiter.
2. StringJoiner(CharSequence delimiter, CharSequence prefix, CharSequence suffix): Creates a new StringJoiner with the specified delimiter, prefix, and suffix.
3. StringJoiner(CharSequence delimiter, CharSequence prefix, CharSequence suffix): Creates a new StringJoiner with the specified delimiter, prefix, and suffix, and with the ability to handle empty values.

To use StringJoiner, you first create an instance with the desired delimiter and optional prefix and suffix. You can then add strings to the joiner using the add method, which appends the string to the current string being built and adds the delimiter if necessary. Finally, you can retrieve the joined string using the toString method.

Here’s an example:

StringJoiner joiner = new StringJoiner(", ", "[", "]");
joiner.add("apple");
joiner.add("banana");
joiner.add("orange");
String joined = joiner.toString(); // "[apple, banana, orange]"

In this example, the delimiter is a comma followed by a space, the prefix is an opening square bracket, and the suffix is a closing square bracket. The add method is called three times to add the strings “apple”, “banana”, and “orange”, respectively. Finally, the toString method is called to retrieve the joined string.

StringJoiner Constructors:

Sure! The StringJoiner class in Java provides three constructors that you can use to create instances of the class. Here are the details of each constructor:

1. StringJoiner(CharSequence delimiter): This constructor creates a new StringJoiner instance with the specified delimiter. The delimiter parameter is a character sequence that is used to separate the strings that will be added to the joiner. For example, if you specify a delimiter of “, “, the joiner will separate the strings with a comma followed by a space.
2. StringJoiner(CharSequence delimiter, CharSequence prefix, CharSequence suffix): This constructor creates a new StringJoiner instance with the specified delimiter, prefix, and suffix. The delimiter parameter is the same as in the previous constructor. The prefix parameter is a character sequence that will be added to the beginning of the joined string. The suffix parameter is a character sequence that will be added to the end of the joined string. For example, if you specify a delimiter of “, “, a prefix of “[“, and a suffix of “]”, the joiner will produce a string that starts with “[” and ends with “]” and separates the strings with a comma followed by a space.
3. StringJoiner(CharSequence delimiter, CharSequence prefix, CharSequence suffix): This constructor creates a new StringJoiner instance with the specified delimiter, prefix, suffix, and handling for empty values. The delimiter, prefix, and suffix parameters are the same as in the previous constructor. The additional parameter, emptyValue, is a character sequence that will be used instead of an empty string if an empty value is added to the joiner. If you don’t specify an emptyValue, an empty string will be used by default. For example, if you specify a delimiter of “, “, a prefix of “[“, a suffix of “]”, and an empty value of “(none)”, the joiner will produce a string that starts with “[” and ends with “]” and separates the strings with a comma followed by a space. If an empty value is added to the joiner, it will be replaced with “(none)” instead of an empty string.

StringJoiner Methods:

Sure, here are the methods provided by the StringJoiner class in Java:

1. add(CharSequence csq): This method adds the specified character sequence to the joiner. If this is the first string added, it is added without a delimiter. If there are already one or more strings in the joiner, the delimiter is added before the new string.
2. merge(StringJoiner other): This method merges the contents of the specified StringJoiner other into this StringJoiner. The delimiter of the other StringJoiner is used between the last element of this StringJoiner and the first element of the other StringJoiner.
3. toString(): This method returns the joined string as a String object.
4. length(): This method returns the length of the current string being built by the StringJoiner. The length includes the prefix and suffix, but not the delimiter.
5. setEmptyValue(CharSequence emptyValue): This method sets the value that will be used instead of an empty string when the joiner is empty. By default, an empty string is used.

These are the main methods provided by the StringJoiner class. You can use them to add strings, retrieve the joined string, and modify the joiner’s behavior.

Java StringJoiner Example:

Sure! Here’s an example that demonstrates how to use the StringJoiner class in Java:

import java.util.StringJoiner;

public class StringJoinerExample {
    public static void main(String[] args) {
        StringJoiner joiner = new StringJoiner(", ", "[", "]");
        joiner.add("apple");
        joiner.add("banana");
        joiner.add("orange");
        String fruits = joiner.toString();
        System.out.println(fruits); // [apple, banana, orange]
    }
}

In this example, we create a new StringJoiner instance with a delimiter of “, “, a prefix of “[“, and a suffix of “]”. We then add three strings (“apple”, “banana”, and “orange”) to the joiner using the add() method. Finally, we retrieve the joined string using the toString() method and print it to the console.

When you run this example, the output will be:

[apple, banana, orange]

As you can see, the StringJoiner class makes it easy to join strings with a delimiter and optional prefix and suffix.

Java StringJoiner Example: adding prefix and suffix:

Sure, here’s an example that demonstrates how to use the StringJoiner class with a prefix and a suffix:

import java.util.StringJoiner;

public class StringJoinerExample {
    public static void main(String[] args) {
        StringJoiner joiner = new StringJoiner(", ", "[", "]");
        joiner.add("apple");
        joiner.add("banana");
        joiner.add("orange");
        String fruits = joiner.toString();
        System.out.println(fruits); // [apple, banana, orange]

        StringJoiner joiner2 = new StringJoiner(", ", "Fruits: [", "]");
        joiner2.add("apple");
        joiner2.add("banana");
        joiner2.add("orange");
        String fruits2 = joiner2.toString();
        System.out.println(fruits2); // Fruits: [apple, banana, orange]
    }
}

In this example, we create two instances of StringJoiner with different prefixes and suffixes. The first StringJoiner instance has a prefix of “[” and a suffix of “]”, while the second StringJoiner instance has a prefix of “Fruits: [” and a suffix of “]”. We then add three strings (“apple”, “banana”, and “orange”) to each joiner using the add() method. Finally, we retrieve the joined string using the toString() method and print it to the console.

When you run this example, the output will be:

[apple, banana, orange]
Fruits: [apple, banana, orange]

import java.util.StringJoiner;

public class StringJoinerExample {
    public static void main(String[] args) {
        StringJoiner joiner1 = new StringJoiner(", ");
        joiner1.add("apple");
        joiner1.add("banana");
        joiner1.add("orange");

        StringJoiner joiner2 = new StringJoiner(", ");
        joiner2.add("grape");
        joiner2.add("pineapple");

        joiner1.merge(joiner2);

        String fruits = joiner1.toString();
        System.out.println(fruits); // apple, banana, orange, grape, pineapple
    }
}

apple, banana, orange, grape, pineapple

import java.util.StringJoiner;

public class StringJoinerExample {
    public static void main(String[] args) {
        StringJoiner joiner = new StringJoiner(", ");
        joiner.setEmptyValue("No fruits yet");
        System.out.println(joiner.toString()); // No fruits yet

        joiner.add("apple");
        joiner.add("banana");
        joiner.add("orange");
        System.out.println(joiner.toString()); // apple, banana, orange

        joiner.add("");
        joiner.add("grape");
        joiner.add("pineapple");
        System.out.println(joiner.toString()); // apple, banana, orange, , grape, pineapple

        joiner.setEmptyValue("No fruits at all");
        System.out.println(joiner.toString()); // apple, banana, orange, , grape, pineapple

        joiner = new StringJoiner(":");
        joiner.add("1");
        joiner.add("2");
        joiner.add("3");
        System.out.println(joiner.toString()); // 1:2:3
    }
}