How to skip a particular string during string Joining in Java?

Question

The source code I have uploaded it will join some strings value in a one line. I want a way that I can able to skip a particular string in time of string joining. Here i have stored the strings "This","is","a","test." in a string array. I want that in time of joining a particular string will be skipped. Like I want to skip "a". How can I able to do in Java? I want a generalized way that I will able to apply for any strings.

import java.util.StringJoiner;
public class Test_Joiner_for_seatPlan
    {
    public static void main(String[] args)
        {
            StringJoiner joinString = new StringJoiner( " ");
            String[] testStringArray = {"This","is","a","test."};

            String joinedString = null;

            for(String s : testStringArray)
              {
                joinString.add(s);
              }

            joinedString = joinString.toString();

            System.out.println("After Joining the String:\n"+joinedString);
        }
    }

Answer 1

Try with not equal condition with string. but its not feasible as its check everytime a value.

for(String s : testStringArray)
{
  if(!s.equals("a")){
      joinString.add(s);
   }
}

If you have a list of values like a,b,c than you can do like this:

 Set<String> exclude =  new HashSet<String>(Arrays.asList("a","b","c"));
 for(String s : testStringArray)
    {
      if(!exclude.contains(s)){
          joinString.add(s);
       }
  }

Answer 2

You can do it like this:
Code:

for(String s : testStringArray){ 
    if(!s.equals("a")){  // replace 'a' with the required character or word you want to ignore
       joinString.add(s);
    }
 }

Answer 3

One possible solution is to provide a Map or a List in which you store the String values that should get excluded in your join. Here is an example using a Map.

public static void main(String[] args) {
    String[] testStringArray = {"This","is","a","test."};
    Map<String, String> excludedStrings = createExcludingMap("a");
    System.out.println("After Joining the String:\n" + join(testStringArray, excludedStrings));
}

private static String join(String[] inputData, Map<String, String> excludedStrings){
    StringJoiner joinString = new StringJoiner( " ");

    String joinedString = null;

    for(String s : inputData)
    {
        if(excludedStrings.get(s) == null) // IF this return null, the String is not part of the Strings to be excluded, hence join the string
            joinString.add(s);
    }

    joinedString = joinString.toString();

    return joinString.toString();
}


private static Map<String, String> createExcludingMap(String... values) {
    Map<String, String> output = new HashMap<>();
    for(String s : values) { // Add each value to the map, with s as key
        output.put(s, s);
    }
    return output;
}

output :/

After Joining the String:
This is test.

Answer 4

Use Split method of string. It returns array. combine each of them to get the string.

for (String retval: Str.split("a")){
         System.out.println(retval);
      }

Answer 5

The StringJoiner is a utility class that was written specifically to be used with the new Java8 Stream functionality. The documentation of StringJoiner also refers to the Collectors.joining method. It creates the StringJoiner, and wraps it in an object suitable to pass to Stream.collect, actually a Collector.

As part of the Stream API we now also have direct support for filters, it is just a matter of employing the fluent API (fluent because we keep adding .something(...)) to add the .filter method.

You can use it as you did in your answer, but I would suggest doing it as follows:

import static java.util.stream.Collectors.joining;
import java.util.function.Predicate;
import java.util.stream.Stream;

public class App {
  public static String joinString(String [] sa,Predicate<String> filter) {
    return Stream.of(sa).filter(filter).collect(joining(" "));
  }

  public static void main(String[] args) {
    String[] testStringArray = new String [] {"This","is","a","test."};
    System.out.println(joinString(testStringArray,(s)->!s.equals("a")));
  }
}

I have deliberately broken it up by defining an extra method, so you can see the type of the filter passed along, exposing the Predicate. This would also make your function a little more generic making it work as you stated: 'I want a generalized way that I will able to apply for any strings'.

However if the Stream api is flexible enough that I do not see any need to abstract your own API for it. I suggest using it as-is:

import static java.util.stream.Collectors.joining;
import java.util.stream.Stream;

public class App {
  public static void main(String[] args) {
    System.out.println(
      Stream
        .of(new String [] {"This","is","a","test."})
        .filter((s)->!s.equals("a"))
        .collect(joining(" "))
    );
  }
}

I could have written most of it on a single line, but I like to break it up for readability.