Question

比方说，我有一个字符串列表，我想按过滤字符串列表进行过滤。对于包含以下内容的列表： “ abcd”，“ xcfg”，“ dfbf”

我将精确列出过滤字符串： “ a”，“ b”以及类似filter（i-> i.contains（filterStrings）之类的东西之后，我想接收“ abcd”，“ dfbf”的列表，对于过滤字符串的列表： “ c”，“ f”我想列出“ xcfg”和“ dfbf”的列表。

List<String> filteredStrings = filteredStrings.stream()
            .filter(i -> i.contains("c") || i.contains("f")) //i want to pass a list of filters here
            .collect(Collectors.toList());

还有其他方法可以代替扩展lambda表达式主体并编写带有标志的函数来检查每个过滤器吗？

Answer 1

您应该在列表上执行anyMatch来匹配：

List<String> input = Arrays.asList("abcd", "xcfg", "dfbf"); // your input list
Set<String> match = new HashSet<>(Arrays.asList("c", "f")); // to match from
List<String> filteredStrings = input.stream()
        .filter(o -> match.stream().anyMatch(o::contains))
        .collect(Collectors.toList());

Answer 2

您可以使用简单的正则表达式来更改contains：

.filter(i -> i.matches(".*[cf].*")) // to check just one character

或：

.filter(i -> i.matches(".*(c|f).*")) // or if you have a words

Answer 3

过滤器可以表示为Predicate。您的情况是Predicate<String>。因此，过滤器列表可以存储在List<Predicate<String>>中。

现在，如果要在Stream的每个元素上应用这样的列表：

List<String> filteredStrings = input.stream()
                                    .filter(i -> filterList.stream().anyMatch(f -> f.test(i))) 
                                    .collect(Collectors.toList());

要完成示例：

List<String> input = new ArrayList<>(Arrays.asList ("abcd", "xcfg", "dfbf","erk"));
List<Predicate<String>> filterList = new ArrayList<>();
filterList.add (i -> i.contains("c"));
filterList.add (i -> i.contains("f"));
List<String> filteredStrings = input.stream()
                                    .filter(i -> filterList.stream().anyMatch(f -> f.test(i))) 
                                    .collect(Collectors.toList());
System.out.println (filteredStrings);

输出：

[abcd, xcfg, dfbf]

Answer 4

您可以使用Pattern：

static final Pattern pattern = Pattern.compile("c|f");

然后检查字符串是否与所述模式匹配。

List<String> strings = filteredStrings.stream()
    .filter(s -> pattern.matcher(s).find())
    .collect(Collectors.toList());

pattern当然可以通过给定的输入来计算：

public static Pattern compute(String... words) {
    StringBuilder pattern = new StringBuilder();
    for(int i = words.length - 1; i >= 0; i++) {
       pattern.append(words[i]);
       if(i != 0) {
           pattern.append('|');
       }
    }
    return Pattern.compile(pattern);
}

然后可以这样称呼：

Pattern patten = compute("some", "words", "hello", "world");

这将导致正则表达式：

some|words|hello|world

java流过滤器列表

4 个答案: