Java 8 removing an item from array/array list based on regex
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.
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
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());