如何从Java中的字符串中删除字符串数组中除元素以外的所有内容？

Question

I'm trying to remove everything from a string unless it matches an element in an array of strings. I can do this with individual characters with.

char[] chars = {'1','2','3'};
  String foo = "abc123 foo !@#";
  String newFoo = "";
  for(int i = 0; i < foo.length(); i++){
     for(char c : chars){
        if(foo.charAt(i) == c){
           newFoo+=c;
        }
     }
  }

then newFoo will be "123" because all the other characters have been removed, except the ones in the array chars (1,2,3). this code takes the string foo and removes all characters that are not in the array chars and make the string newFoo with the remaining characters. here is a flow chart of that program flow chart

I'm looking for how to do this with an array of strings instead of an array of characters with code along these lines.

String[] strings = {"1","2","10"};
String foo = "1 2 3 4 5 6 7 8 9 10"
String newString = "";
//some code here

in the end, newString will end up being "1210". I have been trying at this for a few hours but have yet to come up with a working code to do this, any help would be appreciated.

Answer 1

This may not quite work in all situations, but for the specific example you've posted, we can achieve your result with the code below.

Basically, we convert your array to a List to access the contains() method. Then we split the original foo String so we can check if any of those values exist in the original array.

import java.util.Arrays;
import java.util.List;

class Test {
    public static void main(String[] args) {

        String[] strings = {"1", "2", "10"};
        String foo = "1 2 3 4 5 6 7 8 9 10";

        // We'll use a StringBuilder for this
        StringBuilder newString = new StringBuilder();

        // First, we'll convert our strings array to a List so we have access to the [contains] method
        List<String> stringsList = Arrays.asList(strings);

        // Now, let's split foo into an array, using the space as a delimiter
        String[] foos = foo.split(" ");

        // Loop through each entry of foos and compare to each element in stringsList
        for (int i = 0; i < foos.length; i++) {

            if (stringsList.contains(foos[i])) {
                newString.append(foos[i]);
            }
        }

        System.out.println(newString);
    }
}

---

Running this example produces the final output of: 1210

Answer 2

Here is my solution :

    String[] chars = {"1","2","10"};
    //sort the array by length, so we check the longest string first.
    Arrays.sort(chars, (a,b)->b.length()-a.length());
    String foo = "1 2 3 4 5 6 7 8 9 10";
    String newFoo = "";
    for(int i = 0; i <= foo.length();){
        int j = i;
        for(String s : chars){
            if(foo.length() > i + s.length()){
                //find subString instead of character.
                String sub = foo.substring(i, i + s.length());
                if (sub.equals(s)) {
                    //move to the next index. Ex if 10 is at 0, next check start at 2
                    i += sub.length();
                    newFoo += sub;
                    break;
                }
            }
        }
        // check the index if it has been modified
        i = i == j ? ++j : i;
    }
    System.out.println(newFoo);

Answer 3

You can try a code below. If you want to skip duplicates, you can use Set ,

 String[] strings = {"1", "2", "10"};
String foo = "1 2 3 4 5 6 7 8 9 10".replaceAll("\\s","");

StringBuilder newString = new StringBuilder();

List<String> stringsList = Arrays.asList(strings);

//Set can be used to avoid duplicates like "1 1 2 2 4 4"
Set<String> resSet=new HashSet<String>();
// Loop through each entry of foos and compare to each element in stringsList
for (int i = 0; i < foo.length(); i++) {
    //if current char and next is 10 add it and continue
    if((String.valueOf(foo.charAt(i))+String.valueOf(foo.charAt(i+1))).equals("10") && stringsList.contains("10"))
    {
        resSet.add("10");

        //Extra operation in case you want to avoid duplication
        newString.append(10);
        i++;
        continue;
    }
    //if match found add it
    if (stringsList.contains(String.valueOf(foo.charAt(i)))) {
        newString.append(String.valueOf(foo.charAt(i)));

      //Extra operation in case you want to avoid duplication
        resSet.add(String.valueOf(foo.charAt(i)));
    }
}

System.out.println(newString);
System.out.println(resSet);

Answer 4

I would place them into a HashSet then filter out the characters which arent in that set.

// put in a nice hash set for speedy lookups.
Set<Character> chars = new HashSet(Arrays.asList('1','2','3'));

// method 1
String foo = "abc123 foo !@#";
String newFoo = "";
for(int i = 0; i < foo.length(); i++){
    char c = foo.charAt(i);
    if(!chars.contains(c)) {
        newFoo += c;
    }
}
System.out.println(newFoo);

// method 2
String result = foo.chars()
        .mapToObj(c -> (char)c)
        .filter(c -> !chars.contains(c))
        .map(c -> String.valueOf(c))
        .collect(Collectors.joining(""));
System.out.println("result is: "+result);