设计模式（八）过滤器模式

深藏阁楼爱情的钟 2022-09-30 09:52 150阅读 0赞

过滤器也是一种结构型模式，它允许我们使用不同的规则过滤某一组对象。

首先我们来编写一个实体类，用作被过滤的对象。

public class Person { 
        private int age;
        private String name;
        private Gender gender;
    
        @Override
        public String toString() {
            final StringBuilder sb = new StringBuilder("Person{");
            sb.append("age=").append(age);
            sb.append(", name='").append(name).append('\'');
            sb.append(", gender=").append(gender);
            sb.append('}');
            return sb.toString();
        }
    
        public int getAge() {
            return age;
        }
    
        public void setAge(int age) {
            this.age = age;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public Gender getGender() {
            return gender;
        }
    
        public void setGender(Gender gender) {
            this.gender = gender;
        }
    
        public Person(int age, String name, Gender gender) {
    
            this.age = age;
            this.name = name;
            this.gender = gender;
        }
    }
    
    enum Gender {
        Male, Female
    }

然后来编写过滤器。这里编写了两个过滤器，过滤年龄和性别的。还编写了一个与过滤器，用于同时应用两个过滤器。

public interface Filter { 
        List<Person> filter(List<Person> people);
    }
    
    class AgeGreaterThan20Filter implements Filter { 
    
        @Override
        public List<Person> filter(List<Person> people) {
            List<Person> result = new ArrayList<>();
            for (Person p : people) {
                if (p.getAge() > 20) {
                    result.add(p);
                }
            }
            return result;
        }
    }
    
    class FemaleFilter implements Filter { 
    
        @Override
        public List<Person> filter(List<Person> people) {
            List<Person> result = new ArrayList<>();
            for (Person p : people) {
                if (p.getGender() == Gender.Female) {
                    result.add(p);
                }
            }
            return result;
        }
    }
    
    class AndFilter implements Filter { 
        private Filter one;
        private Filter other;
    
        public AndFilter(Filter one, Filter other) {
            this.one = one;
            this.other = other;
        }
    
        @Override
        public List<Person> filter(List<Person> people) {
            List<Person> tmp = one.filter(people);
            return other.filter(tmp);
        }
    }

之后来测试一下。我们可以看到，由于过滤器和实体类解耦，所以我们可以随便使用过滤器来处理数据。

List<Person> people = new ArrayList<>();
    people.add(new Person(22, "yitian", Gender.Male));
    people.add(new Person(23, "zhang3", Gender.Female));
    people.add(new Person(24, "li4", Gender.Male));
    people.add(new Person(25, "wang5", Gender.Female));
    people.add(new Person(13, "zhao6", Gender.Male));
    people.add(new Person(10, "fuck", Gender.Female));
    Filter femaleFilter = new FemaleFilter();
    List<Person> women = femaleFilter.filter(people);
    System.out.println("女人们:" + women);
    Filter ageGreaterThan20Filter = new AgeGreaterThan20Filter();
    List<Person> gt20 = ageGreaterThan20Filter.filter(people);
    System.out.println("大于20的人:" + gt20);
    
    Filter andFilter = new AndFilter(femaleFilter, ageGreaterThan20Filter);
    System.out.println("既是女性有大于20的人:" + andFilter.filter(people));

如果使用过Java 8的话会发现lambda表达式和流类库会帮我们非常方便的实现过滤器模式的功能。

//lambda表达式
    List<Person> men = people.stream()
            .filter(o -> o.getGender() == Gender.Male)
            .filter(o -> o.getAge() >= 23)
            .collect(Collectors.toList());
    System.out.println("大于23的男性:" + men);

通过新的语言特性，我们可以简化设计模式的使用，更快速的开发程序。当然，了解设计模式还是很有必要的。领会设计模式的思想，可以让我们更深刻的理解程序设计的奥秘，对我们学习编程还是很有帮助的。