Combining a Collection of Predicates

public void whenFilterListWithCollectionOfPredicatesUsingAnd_thenSuccess(){
    List<Predicate<String>> allPredicates = new ArrayList<Predicate<String>>();
    allPredicates.add(str -> str.startsWith("A"));
    allPredicates.add(str -> str.contains("d"));        
    allPredicates.add(str -> str.length() > 4);
    
    List<String> result = names.stream()
      .filter(allPredicates.stream().reduce(x->true, Predicate::and))
      .collect(Collectors.toList());
    
    assertEquals(1, result.size());
    assertThat(result, contains("Alexander"));
}

package fengliang.firstjava;

import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.*;
import java.util.function.Predicate;

class FilterContainer<T> {
    protected List<T> list = new ArrayList<>();

    public FilterContainer<T> addFilter(T predicate) {
        list.add(predicate);
        return this;
    }

    public List<T> getList() {
        return list;
    }
}
public class LambdaExamination {

    protected static List<Employee> createDepartment() {

        return new ArrayList<>(Arrays.asList(
                new Employee("张三", 12, "2012-11-12"),
                new Employee("李四", 9, "2018-06-01"),
                new Employee("王五", 11.5, "2019-06-01"),
                new Employee("赵六", 11.2, "2018-11-02"),
                new Employee("孙七", 8, "2020-08-08")
        ));
    }

    protected static Comparator<Employee> sortBySalary() {

        return Comparator.comparingDouble(Employee::getSalary);
    }

    protected static Date stringDateTimeFormat(String datetime) {
        try {
            return new SimpleDateFormat("y-MM-dd").parse(datetime);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        throw new RuntimeException("datetime的格式必须符合2020-02-01");
    }

    protected static Comparator<Employee> sortByHireDay() {
        return Comparator.comparing((Employee e) -> stringDateTimeFormat(e.getHireDay()));
    }

    protected static Predicate<Employee> filterBySalary(double salary) {
        return (Employee e) -> Double.compare(e.getSalary(), salary) > 0;
    }

    protected static Predicate<Employee> filterByHireDay(String hireDay) {
        return (Employee e) -> stringDateTimeFormat(e.getHireDay()).compareTo(stringDateTimeFormat(hireDay)) > 0;
    }

    public static void main(String[] args) {
        List<Employee> department = createDepartment();
        FilterContainer<Predicate<Employee>> filterContainer = new FilterContainer<>();
        filterContainer.addFilter(filterBySalary(10.0))
                .addFilter(filterByHireDay("2018-10-10"));

        department.stream().filter(filterBySalary(10)).filter(
                filterContainer.getList().stream().reduce(f->true, Predicate::and)
        ).sorted(sortBySalary())
                .forEach(
                employee -> System.out.println(employee.name+", "+ employee.salary+", "+employee.hireDay.toString())
        );
    }
}

 https://www.baeldung.com/java-predicate-chain