过滤器模式

过滤器模式是一种行为型设计模式，也被称为标准模式。它的主要目的是通过一个或多个过滤条件来过滤一个对象集合，并将符合条件的对象提取出来形成一个新的集合。

在实际应用中，过滤器模式通常会用来过滤大型数据集，或者作为一个搜索引擎的一部分来过滤查询结果。

在过滤器模式中，我们定义一个过滤器接口，这个接口包含一个过滤方法，它以一个对象集合作为参数，并返回一个经过过滤的新的对象集合。

下面是一个简单的Java示例，展示了如何使用过滤器模式来过滤一个人员列表：

public class Person {
    private String name;
    private String gender;
    private String maritalStatus;
    public Person(String name, String gender, String maritalStatus) {
        this.name = name;
        this.gender = gender;
        this.maritalStatus = maritalStatus;
    }
    public String getName() {
        return name;
    }
    public String getGender() {
        return gender;
    }
    public String getMaritalStatus() {
        return maritalStatus;
    }
}
public interface Filter {
    List<Person> filter(List<Person> persons);
}
public class MaleFilter implements Filter {
    @Override
    public List<Person> filter(List<Person> persons) {
        List<Person> malePersons = new ArrayList<>();
        for (Person person : persons) {
            if (person.getGender().equalsIgnoreCase("MALE")) {
                malePersons.add(person);
            }
        }
        return malePersons;
    }
}
public class FemaleFilter implements Filter {
    @Override
    public List<Person> filter(List<Person> persons) {
        List<Person> femalePersons = new ArrayList<>();
        for (Person person : persons) {
            if (person.getGender().equalsIgnoreCase("FEMALE")) {
                femalePersons.add(person);
            }
        }
        return femalePersons;
    }
}
public class SingleFilter implements Filter {
    @Override
    public List<Person> filter(List<Person> persons) {
        List<Person> singlePersons = new ArrayList<>();
        for (Person person : persons) {
            if (person.getMaritalStatus().equalsIgnoreCase("SINGLE")) {
                singlePersons.add(person);
            }
        }
        return singlePersons;
    }
}
public class AndFilter implements Filter {
    private Filter filter1;
    private Filter filter2;
    public AndFilter(Filter filter1, Filter filter2) {
        this.filter1 = filter1;
        this.filter2 = filter2;
    }
    @Override
    public List<Person> filter(List<Person> persons) {
        List<Person> firstFilteredPersons = filter1.filter(persons);
        return filter2.filter(firstFilteredPersons);
    }
}
public class OrFilter implements Filter {
    private Filter filter1;
    private Filter filter2;
    public OrFilter(Filter filter1, Filter filter2) {
        this.filter1 = filter1;
        this.filter2 = filter2;
    }
    @Override
    public List<Person> filter(List<Person> persons) {
        List<Person> firstFilteredPersons = filter1.filter(persons);
        List<Person> secondFilteredPersons = filter2.filter(persons);
        for (Person person : secondFilteredPersons) {
            if (!firstFilteredPersons.contains(person)) {
                firstFilteredPersons.add(person);
            }
        }
        return firstFilteredPersons;
    }
}
public class FilterPatternDemo {
    public static void main(String[] args) {
        List<Person> persons = new ArrayList<>();
        persons.add(new Person("Robert","Male", "Single"));
        persons.add(new Person("John","Male", "Married"));
        persons.add(new Person("Laura","Female", "Married"));
        persons.add(new Person("Diana","Female", "Single"));
        persons.add(new Person("Mike","Male", "Single"));
        persons.add(new Person("Bobby","Male", "Single"));
        Filter maleFilter = new MaleFilter();
        Filter femaleFilter = new FemaleFilter();
        Filter singleFilter = new SingleFilter();
        Filter singleMaleFilter = new AndFilter(singleFilter, maleFilter);
        Filter singleOrFemaleFilter = new OrFilter(singleFilter, femaleFilter);
        System.out.println("Males: ");
        printPersons(maleFilter.filter(persons));
        System.out.println("\nFemales: ");
        printPersons(femaleFilter.filter(persons));
        System.out.println("\nSingle Males: ");
        printPersons(singleMaleFilter.filter(persons));
        System.out.println("\nSingle Or Females: ");
        printPersons(singleOrFemaleFilter.filter(persons));
    }
    public static void printPersons(List<Person> persons) {
        for (Person person : persons) {
            System.out.println("Person : [Name : " + person.getName() 
                               + ", Gender : " + person.getGender() 
                               + ", Marital Status : " + person.getMaritalStatus() 
                               + "]");
        }
    }
}

在这个示例中，Person类代表了一个人员，它包含了姓名、性别和婚姻状况等属性。Filter接口定义了过滤器的标准，包含了一个filter()方法。MaleFilter、FemaleFilter、SingleFilter是具体的过滤器实现，用来对人员进行性别和婚姻状况的过滤。AndFilter、OrFilter是过滤器的组合方式，用来对多个过滤器进行组合的操作。

通过使用过滤器模式，我们可以方便地定义一组过滤条件，并将这些条件应用到一个对象集合中，从而筛选出符合条件的对象。这种方式非常灵活和高效，可以轻松地扩展和组合不同的过滤器，以满足不同的需求。