Java设计模式之过滤器模式（Filter Pattern）

过滤器模式（Filter Pattern）是一种常用的设计模式，它用于通过一系列条件来过滤对象集合，并将满足条件的对象保留下来。该模式可以帮助我们在不修改原始对象集合的情况下，根据特定的条件对集合进行筛选和处理。

在过滤器模式中，通常有三个核心角色：

1. 过滤器接口（Filter）：定义了过滤器的基本操作，通常包括一个过滤方法，用于判断对象是否满足条件。

2. 具体过滤器（Concrete Filter）：实现了过滤器接口，根据特定的条件对对象进行过滤。

3. 过滤器管理器（Filter Manager）：负责管理和应用过滤器，它维护一个过滤器链，并提供方法来添加、移除和执行过滤器。

下面是一个示例，展示了如何使用过滤器模式来过滤一组学生对象：

// 1. 过滤器接口
interface Filter {
    boolean matches(Student student);
}

// 2. 具体过滤器实现
class AgeFilter implements Filter {
    private int age;

    public AgeFilter(int age) {
        this.age = age;
    }

    @Override
    public boolean matches(Student student) {
        return student.getAge() == age;
    }
}

class GradeFilter implements Filter {
    private String grade;

    public GradeFilter(String grade) {
        this.grade = grade;
    }

    @Override
    public boolean matches(Student student) {
        return student.getGrade().equals(grade);
    }
}

// 3. 过滤器管理器
class FilterManager {
    private List<Filter> filters;

    public FilterManager() {
        this.filters = new ArrayList<>();
    }

    public void addFilter(Filter filter) {
        filters.add(filter);
    }

    public void removeFilter(Filter filter) {
        filters.remove(filter);
    }

    public List<Student> applyFilters(List<Student> students) {
        List<Student> filteredStudents = new ArrayList<>();

        for (Student student : students) {
            boolean matchesAllFilters = true;

            for (Filter filter : filters) {
                if (!filter.matches(student)) {
                    matchesAllFilters = false;
                    break;
                }
            }

            if (matchesAllFilters) {
                filteredStudents.add(student);
            }
        }

        return filteredStudents;
    }
}

// 学生类
class Student {
    private String name;
    private int age;
    private String grade;

    public Student(String name, int age, String grade) {
        this.name = name;
        this.age = age;
        this.grade = grade;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    public String getGrade() {
        return grade;
    }
}

// 使用示例
public class Main {
    public static void main(String[] args) {
        List<Student> students = new ArrayList<>();
        students.add(new Student("Alice", 18, "A"));
        students.add(new Student("Bob", 20, "B"));
        students.add(new Student("Charlie", 18, "A"));

        FilterManager filterManager = new FilterManager();
        filterManager.addFilter(new AgeFilter(18));
        filterManager.addFilter(new GradeFilter("A"));

        List<Student> filteredStudents = filterManager.applyFilters(students);

        for (Student student : filteredStudents) {
            System.out.println("Name: " + student.getName() + ", Age: " + student.getAge() + ", Grade: " + student.getGrade());
        }
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

在上面的示例中，我们定义了两个具体的过滤器实现：AgeFilter（按年龄过滤）和GradeFilter（按成绩过滤）。然后，我们使用FilterManager来管理这些过滤器，并将它们应用于学生对象集合。最后，我们打印出满足所有过滤条件的学生信息。

通过使用过滤器模式，我们可以轻松地添加、移除和组合不同的过滤器，以满足特定的过滤需求，同时保持代码的可扩展性和可维护性。