根据波动的条件数量过滤列表

Question

我想编写能够使用许多条件来过滤对象列表的代码，但我希望条件的数量波动（有时使用1个字段过滤，有时使用所有3个字段过滤）。

在我的情况下，我希望用户可以为某个字段选择“任何”，但仍然对其他字段应用过滤器。在下面的情况下，用户可以通过字段< code>x，y

我已经编写了下面的代码，可以在这种情况下工作，但在将来添加更多过滤器时效率会越来越低。（2个过滤器导致4个返回语句，3个过滤器导致8个返回语句等等）。

private static ArrayList<Model> getFilteredList(ArrayList<Model> originalList, String x, String y, String z ){

    if(x.equals("any") && y.equals("any") && z.equals("any")) {
        return originalList;
    }
    if(x.equals("any") && y.equals("any") && !z.equals("any")) {
        return originalList.stream().filter(item -> item.getZ().equals(z)).collect(Collectors.toCollection(ArrayList::new));
    }
    if(x.equals("any") && !y.equals("any") && z.equals("any")) {
        return originalList.stream().filter(item -> item.getY().equals(y)).collect(Collectors.toCollection(ArrayList::new));
    }
    if(x.equals("any") && !y.equals("any") && !z.equals("any")) {
        return originalList.stream().filter(item -> item.getY().equals(y)&& item.getZ().equals(z)).collect(Collectors.toCollection(ArrayList::new));
    }
    if(!x.equals("any") && y.equals("any") && z.equals("any")) {
        return originalList.stream().filter(item -> item.getX().equals(x)).collect(Collectors.toCollection(ArrayList::new));
    }
    if(!x.equals("any") && y.equals("any") && !z.equals("any")) {
        return originalList.stream().filter(item -> item.getX().equals(x)&& item.getZ().equals(z)).collect(Collectors.toCollection(ArrayList::new));
    }
    if(!x.equals("any") && !y.equals("any") && z.equals("any")) {
        return originalList.stream().filter(item -> item.getX().equals(x)&& item.getY().equals(y)).collect(Collectors.toCollection(ArrayList::new));
    }
    if(!x.equals("any") && !y.equals("any") && !z.equals("any")) {
        return originalList.stream().filter(item -> item.getX().equals(x)&& item.getY().equals(y)&& item.getZ().equals(z)).collect(Collectors.toCollection(ArrayList::new));
    }
    return originalList;
}

以下是模型的外观：

public class Model {
    private String x;
    private String y;
    private String z;

    public String getX() {
        return x;
    }
    public String getY() {
        return y;
    }
    public String getZ() {
        return z;
    }
}

下面的代码将返回一个列表，其中x字段等于“red”，其中y字段等于“media”，其中z字段可以是任何东西。

private static ArrayList<Model> items = new ArrayList<>();

public static void main(String[] args) {
    ArrayList<Model> filteredList = getFilteredList(items, "red", "medium", "any");
}

我不确定是否有更简单的方法来执行我的getFilteredList方法，我已经搜索了很多，但找不到任何更简单/更有效的实现。在未来，我希望允许10个过滤器，其中“any”始终是一个选项，但我当前的解决方案太长，根本不会优雅。如果有人能为如何优雅地过滤具有不同数量过滤器的列表提供任何答案，那将不胜感激。

谢谢。

Answer 1

您可以使用helper方法使用给定的字段和值构造谓词，然后合并这些谓词并将其应用于流：

private static ArrayList<Model> getFilteredList(ArrayList<Model> originalList, String x, String y, String z ){
    Predicate<Model> filter = Stream.of(compare(Model::getX, x), compare(Model::getY, y), compare(Model::getZ, z))
            .filter(Objects::nonNull)
            .reduce(Predicate::and)
            .orElse($ -> true);

    return originalList.stream()
            .filter(filter)
            .collect(Collectors.toCollection(ArrayList::new));
}

private static Predicate<Model> compare(Function<Model, String> field, String value) {
    return value.equals("any") ? null : m -> field.apply(m).equals(value);
}

Answer 2

匿名用户

你可以用

private static List<Model> getFilteredList(
    ArrayList<Model> originalList, String x, String y, String z ){

    if(Stream.of(x, y, z).allMatch("any"::equals)) return originalList;

    Stream<Model> s = originalList.stream();
    if(!"any".equals(x)) s = s.filter(m -> m.getX().equals(x));
    if(!"any".equals(y)) s = s.filter(m -> m.getY().equals(y));
    if(!"any".equals(z)) s = s.filter(m -> m.getZ().equals(z));
    return s.collect(Collectors.toList());
}

但是您应该决定返回类型。ArrayList 的显式返回类型表明调用方收到可变列表，但是当该列表有时是原始列表，有时不是时，根据筛选条件，修改具有未定义的语义，因为它们可能会影响原始列表，这将是灾难性的。

所以你必须决定

> < li>

返回的列表不应该被修改(不要将其声明为< code>ArrayList并且不要强制创建< code>ArrayList)，这就是上面的示例所做的，或者

返回的列表应该是一个不影响源的可变列表，然后去掉所有返回原始列表的优化-"any"，或者

原始列表应该在那之后未使用，或者

对返回列表的修改应该总是影响原始列表

对于c），合约不能在方法中强制执行，对于d），使用流API是不可能的。因此，对于c）或d），最好改为修改原始列表，例如

private static void filterList(ArrayList<Model> list, String x, String y, String z) {
    Predicate<Model> any = m -> false, effective = any;
    if(!"any".equals(x)) effective = m -> !m.getX().equals(x);
    if(!"any".equals(y)) effective = effective.or(m -> !m.getY().equals(y));
    if(!"any".equals(z)) effective = effective.or(m -> !m.getZ().equals(z));
    if(effective != any) list.removeIf(effective);
}

这并没有留下任何关于语义学的疑问。

Answer 3

您可以仅为要过滤的每个String及其相应的Model属性链接流上的过滤器调用。

stringFilterBiFunction确保如果该属性的过滤器是"any"或过滤器等于适当的Model字段中的值，则模型将包含在结果流中。
由于每个过滤器都对最后一个过滤器的输出进行操作，因此我们可以确保没有不满足所有所需条件的Model将包含在返回的列表中。

public List<Model> getFilteredList(List<Model> originalList, String x, String y, String z) {

    final BiPredicate<String, Supplier<String>> stringFilter = (filter, stringSupplier) ->
            filter.equals("any") || filter.equals(stringSupplier.get());

    return originalList.stream()
            .filter(model -> stringFilter.test(x, model::getX))
            .filter(model -> stringFilter.test(y, model::getY))
            .filter(model -> stringFilter.test(z, model::getZ))
            .collect(Collectors.toList());
}

供应商

当我们过滤流时，我们将要过滤的字符串之一和相应的Model getter传递给我们的BiPredicate。getter通过引用传递，并将作为我们的供应商的字符串源。