如何通过 Java 8 中过滤器/谓词的多种组合来检索列表对象？答案

【问题标题】：How to retrieve a list objects by multiple combination of filters/predicates in Java 8?如何通过 Java 8 中过滤器/谓词的多种组合来检索列表对象？
【发布时间】：2019-01-27 20:33:28
【问题描述】：

我需要你的帮助来找出在 java 8 中解决这个问题的最佳方法

我有一个必须分类的对象 X 的列表。

这是我的规则集：

ID  | Filtre1 | Filtre2 | Filtre3 | ValueToApply
1   |  'abc'  |  null   |  null   |  10
2   |  'abc'  |  'def'  |  null   |  25 
3   |  'abc'  |  null   |  'ghi'  |  20

案例 1：我有一个对象 X，其中包含 (value1=abc, value2=def, value3=ghi) 所以代码应该返回包含规则 1、2、3 的列表

案例 2：我有一个对象 X，其中包含 (value1=abc, value2=def, value3=hij) 所以代码应该返回包含规则 1、2 的列表

谢谢

【问题讨论】：

定义“解决此代码的最佳方法”。
GBlodgett 是什么意思？

标签： java list predicate steam

【解决方案1】：

虽然“最佳方式”非常模糊。这是一种解释，至少是一个很好的起点，它结合了用于过滤对象中可扩展的字段的规则列表，不限于字段或对象的数量，易于互换的类型等。

首先让我们定义一些数据对象来捕获数据模型：

static class Rule {
    final int id;
    final int valueToApply;
    final Predicate<String>[] valueFilters;

    public Rule(int id, int valueToApply, Predicate<String>... valueFilters) {
        this.id = id;
        this.valueToApply = valueToApply;
        this.valueFilters = valueFilters;
    }

    @Override
    public String toString() {
        return "Rule{id="+id+", valueToApply="+valueToApply+"}";
    }
}

static class X {
    final String[] values;

    X(String... values) {
        this.values = values;
    }
}

然后是使用它们与数据中建议的主要方法：

public static void main(String[] args) {
    X x1 = new X("abc", "def", "ghi");
    X x2 = new X("abc", "def", "hij");

    List<Rule> rules = new ArrayList<>(Arrays.asList(
            new Rule(1, 10, v->"abc".equals(v)),
            new Rule(2, 25, v->"abc".equals(v), v->"def".equals(v)),
            new Rule(3, 20, v->"abc".equals(v), v->true, v->"ghi".equals(v))
    ));

    Collection<Rule> rulesResult = classify(x1, rules);
    System.out.println("Case 1:"+rulesResult);
    rulesResult = classify(x2, rules);
    System.out.println("Case 2:"+rulesResult);
}

预期结果：

Case 1:[Rule{id=1, valueToApply=10}, Rule{id=2, valueToApply=25}, Rule{id=3, valueToApply=20}]
Case 2:[Rule{id=1, valueToApply=10}, Rule{id=2, valueToApply=25}]

还有分类方法的“魔力”。

static Collection<Rule> classify(X x, Collection<Rule> rules) {
    List<Rule> result = new ArrayList<>();

    for (Rule rule : rules) {
        for (int i = 0; i < x.values.length; i++) {
            if (rule.valueFilters.length > i && !rule.valueFilters[i].test(x.values[i]))
                continue;
            if (i == x.values.length-1)
                result.add(rule);
        }
    }

    return result;
}

没什么大不了的。 rule.valueFilters.length > i 在那里，因此您不必在所有返回 true 的规则中指定尾随过滤器。

我确信可以使用流，但是如果没有提前终止/延迟评估的好处，那么可读性会存在问题，并且对于像这样的批处理作业很可能效率不高。

循环遍历 X 类的对象。

【讨论】：