如何将 if-else if 将具有多个筛选条件的块代码链接为具有空校验的单个筛选条件？

Question

我确实有一个员工课程

我尝试了以下方法来进行过滤部分，但如果链接正在发生，则有多个if-else。是否有更好的方法将这种链接减少为单个谓词，类似于动态过滤中所做的事情。我使用的链接代码如下：

员工类

public class Employee{
    private String fName;
    private String lName;
    private String type;

    //getters & setters

}

If-else if链接块:

public List<Employee> retrieveEmployees(String searchToken, String fName, String lName, String type){
    //this will retrieve all the available employees 
    List<Employee> employees = getEmployees(); 
    List<Employee> filteredEmployees= new ArrayList<>();

    //perform filtering on the basis of accepted params
    if(searchToken !=null){
        filteredEmployees=employees
        .stream()
        .filter(emp-> emp.getFName().equalsIgnoreCase(searchToken) && emp.getLName().equalsIgnoreCase(searchToken))
        .collect(Collectors.toList());

    }
    else if (fName != null && lName != null && type != null) {
        filteredEmployees=employees
        .stream()
        .filter(emp-> emp.getFName().equalsIgnoreCase(fName) && emp.getLName().equalsIgnoreCase(lName) && emp.getType().equalsIgnoreCase(type))
        .collect(Collectors.toList());
    } else if (type != null && fname != null && lname == null) {
        filteredEmployees=employees
        .stream()
        .filter(emp-> emp.getFName().equalsIgnoreCase(fName) && emp.getType().equalsIgnoreCase(type))
        .collect(Collectors.toList());
    } else if (fname != null && lname != null && type == null) {
        filteredEmployees=employees
        .stream()
        .filter(emp-> emp.getFName().equalsIgnoreCase(fName) && emp.getLName().equalsIgnoreCase(lName))
        .collect(Collectors.toList());
    } else if (lname != null && type != null && fname == null) {
        filteredEmployees=employees
        .stream()
        .filter(emp-> emp.getLName().equalsIgnoreCase(lName) && emp.getType().equalsIgnoreCase(type))
        .collect(Collectors.toList());
    } else if (fname != null && lname == null && type == null) {
        filteredEmployees=employees
        .stream()
        .filter(emp-> emp.getFName().equalsIgnoreCase(fName))
        .collect(Collectors.toList());
    } else if (lname != null && fname == null && type == null) {
        filteredEmployees=employees
        .stream()
        .filter(emp-> emp.getLName().equalsIgnoreCase(lName))
        .collect(Collectors.toList());
    } else if (type != null && fname == null && lname == null) {
        filteredEmployees=employees
        .stream()
        .filter(emp-> emp.getType().equalsIgnoreCase(type))
        .collect(Collectors.toList());
    } else {
        filteredEmployees=getEmployees();
    }


    return filteredEmployees;
}

我尝试过类似的方法，但是失败了，因为谓词本身只是执行< code >或/和操作，它不满足我在< code>if-else if块中所做的操作:

List<Predicate<Employee>> predicates=Arrays.asList(
            e -> e.getFName().equalsIgnoreCase(fName),
            e -> e.getLName().equalsIgnoreCase(lName),
            e -> e.getType().equals(type)
    );

Predicate<Employee> compositePredicate = predicates
    .stream()
    .reduce(w -> true, Predicate::or); //tried with 'and' as well

filteredEmployees= employees
    .stream()
    .filter(compositePredicate)
    .collect(Collectors.toList());

我缺少什么？可以应用什么有效的流谓词链方法？

Answer 1

您可以有一个类SearchFilter，它将包含您的所有过滤器字段，例如search chToken、fname等。和另一个条件，例如：

class Condition {
    private Predicate<SearchFilter> searchFilterPredicate;
    private Function<SearchFilter, Predicate<Employee>> function;
}

然后，您可以定义一个包含所有条件的静态不可变列表：

List<Condition> conditions = Arrays.asList(
    new Condition(sf -> sf.getSearchToken() != null,
                  sf -> emp -> emp.getFName().equalsIgnoreCase(sf.getSearchToken()) && emp.getLName().equalsIgnoreCase(sf.getSearchToken())),
    new Condition(sf -> ObjectUtils.allNotNull(sf.getFname(), sf.getLname(), sf.getType()),
                  sf -> emp-> emp.getFName().equalsIgnoreCase(sf.getFname()) && emp.getLName().equalsIgnoreCase(sf.getLname()) && emp.getType().equalsIgnoreCase(sf.getType()))
    //...
);

最后是< code>retrieveEmployees方法

public List<Employee> retrieveEmployees(String searchToken, String fname, String lname, String type){
    List<Employee> employees = getEmployees();
    SearchFilter searchFilter = new SearchFilter(searchToken, fname, lname, type);

    Optional<Predicate<Employee>> firstCondition = conditions.stream()
            .filter(condition -> condition.getSearchFilterPredicate().test(searchFilter))
            .findFirst()
            .map(condition -> condition.getFunction().apply(searchFilter));

    return firstCondition.map(employeePredicate -> employees.stream()
                .filter(employeePredicate)
                .collect(Collectors.toList()))
            .orElse(employees);
}

另一种解决方案可能是检查每个过滤器字段并将其添加到谓词中

List<Employee> retrieveEmployees(String searchToken, String fname, String lname, String type){
    List<Employee> employees = getEmployees();
    if(searchToken != null) {
        return employees
                .stream()
                .filter(emp -> emp.getFName().equalsIgnoreCase(searchToken) && emp.getLName().equalsIgnoreCase(searchToken))
                .collect(Collectors.toList());

    }
    Predicate<Employee> predicate = employee -> true;

    if(type != null) {
        predicate = predicate.and(emp -> emp.getType().equalsIgnoreCase(type));
    }
    if(lname != null) {
        predicate = predicate.and(emp -> emp.getLName().equalsIgnoreCase(lname));
    }
    if(fname != null) {
        predicate = predicate.and(emp -> emp.getFName().equalsIgnoreCase(fname));
    }

    return employees.stream()
             .filter(predicate)
             .collect(Collectors.toList());
}