Java 8基于正则表达式从数组/数组列表中删除项目

Question

Is there a better way to achieve the following in java 8?

String regex = "^SACHI";
for (String temp : personalNames ) {
    if (temp.matches(regex)){
         personalNames.remove(temp);
    }
}

Answer 1

You can use

personalNames.removeIf(Pattern.compile("^SACHI").asPredicate());

You could also use the simpler

personalNames.removeIf(s -> s.matches("^SACHI"));

but it will perform Pattern.compile("^SACHI") under the hood, for every element in the worst case. Note that the Pattern created by compile is immutable and can be shared, hence, you could also create it only once, like

static final Pattern REMOVAL_PATTERN = Pattern.compile("^SACHI");

and use it like

personalNames.removeIf(REMOVAL_PATTERN.asPredicate());

---

asPredicate() uses find() instead of matches() , but since your pattern has the ^ anchor, it makes no difference. The method asMatchPredicate() for getting a predicate using matches() has been added in JDK 11.

---

If all you want, is to match a literal string at the beginning, you can also use

personalNames.removeIf(s -> s.startsWith("SACHI"));

which does not have the regex initialization overhead.

Answer 2

Adding and/or removing elements from an existing container does not fit in nicely with the concepts of functional programming. More over that behavior is not thread safe in parallel and concurrent environment. Making it thread safe demands more effort too. Therefore prefer steteless lambdas to stateful lambdas as a good engineering practice. You can get the matching names by merely using filter operator. Here's how it looks.

private static final Pattern PATTERN = Pattern.compile("^SACHI");

List<String> validNames = personalNames.stream()
    .filter(PATTERN.asPredicate())
    .collect(Collectors.toList());

Answer 3

It depends did you need to modify existing list, or you need just get list without elements. In first case, you can use stream to filter non matching objects and remove them from list

personalNames.removeAll(
        personalNames
                .stream()
                .filter(x -> !x.matches(regex))
                .collect(Collectors.toList())
);

In other case, you can just return new list with only matching objects

final List<String> matchingElements = personalNames.stream()
        .filter(x -> x.matches(regex))
        .collect(Collectors.toList());

also, this code

for (String temp : personalNames ) {
    if (temp.matches(regex)){
        personalNames.remove(temp);
    }
}

will throw java.util.ConcurrentModificationException

Answer 4

You can extract errorProneNames by filtering and removing respective error names from personalNames iterating forEach :

List<String> errorProneNames = personalNames.stream()
        .filter(name -> !name.matches(regex))
        .collect(Collectors.toList());

errorProneNames.forEach(personalNames::remove);

Answer 5

They are equivalent:

for (String temp : personalNames ) {
   if (temp.matches(regex)){
     personalNames.remove(temp);
   }
}

and

personalNames.removeIf(name -> name.matches(regex));

Answer 6

   String regex = "^SACHI";
   Predicate<String> f = n-> n.matches(regex);
   personalNames.stream().filter(x->f.test(x))
                         .forEach(n-> {
                          personalNames.remove(n);
                          });

Using Predicate<T> to filter out the names which do not matches to String regex . test(T t) evaluates this predicate on the given argument.