Java 过滤器模式

过滤器设计模式，也被称为条件设计模式，是开发人员根据不同条件过滤对象的结构性设计模式。它通过将多个条件链接成一个条件，实现解耦的过滤和逻辑操作。

它提供两种创建过滤器的技术：对整个集合进行过滤或对特定集合成员进行过滤。

要向一个类应用条件，您可以按照以下步骤进行操作：

创建一个需要过滤的类。
开发条件的接口。
实现满足接口要求的具体类。
通过使用各种条件及其组合来过滤出特定的对象。
检查输出，确保获得预期的过滤结果。

如何实施

要实施过滤器设计模式，可以按照以下步骤进行：

创建一个名为“Person”的类，用于表示被过滤的对象。
设计一个名为“Criteria”的接口，以定义过滤条件。
实现满足“Criteria”接口的具体类，以指定不同的过滤条件。
通过选择不同的条件并将它们组合来使用“Criteria”对象过滤“Person”对象的列表。
开发一个名为“CriteriaPatternDemo”的演示类，以展示使用过滤器模式通过应用不同的条件对“Person”对象列表进行过滤的用法。

按照这些步骤，您可以有效地应用过滤器设计模式来基于指定的条件过滤对象。

步骤1

要开始实施过滤器设计模式，我们可以创建一个将应用条件的类。

让我们将这个类命名为“Person.java”。这个类将作为过滤条件依赖的对象。

语法1

下面的代码示例创建了“Person”类以及三个私有示例变量。我们将它们命名为“name”、“genderType”和“maritalStatus”。

该类包括获取这些变量值的方法。它还包括一个用于初始化这些变量的构造函数。

public class Tutorialspoint {

   private String name;
   private String genderType;
   private String maritalStatus;

   public Person(String name, String genderType, String maritalStatus){
      this.name = name;
      this.gender = genderType;
      this.maritalStatus = maritalStatus;       
   }

   public String getName() {
      return name;
   }
   public String getGenderType() {
      return gender;
   }
   public String getMaritalStatus() {
      return maritalStatus;
   }    
}

步骤2

下一步是为标准开发一个接口，以便继续执行筛选设计模式。该接口将定义具体标准类将实现的方法。

语法2

给定的示例代码演示了如何创建“Criterion”接口。

该接口的“meetCriteria”方法接受“Person”对象输入的列表。它被设计为返回符合指定标准的“Person”对象的过滤列表。

import java.util.List;

public interface Criterion {
   public List<Person> meetCriteria(List<Person> persons);
}

步骤3

实现Criteria接口的合法类是将过滤器设计模式付诸实践的下一阶段。作为示例，让我们构造一个名为”CriteriaMale.java”的类。

步骤4

为了实现过滤器设计模式，下一步是创建实现Criteria接口的具体类。我们可以创建一个名为”CriteriaMale.java”的类作为示例。还有其他类提供筛选条件的具体实现，如”Female”，”Single”，使用”And”组合条件和使用”Or”组合条件。

步骤5

为了使用不同的条件及其组合来筛选人员，代码提供了以下实现。

示例1

在CriteriaPatternDemo类中创建了一个Person对象列表，并使用多个条件对该列表进行筛选，包括”male”，”female”，”single”，”singleMale”和”singleOrFemale”。

然后，对每个筛选条件的组合进行打印输出，展示了过滤器设计模式的有效性。

import java.util.ArrayList;
import java.util.List;

interface Criteria {
   List<Person> meetCriteria(List<Person> persons);
}

class CriteriaMale implements Criteria {
   @Override
   public List<Person> meetCriteria(List<Person> persons) {
      List<Person> malePersons = new ArrayList<Person>();
      for (Person person : persons) {
         if (person.getGender().equalsIgnoreCase("Male")) {
            malePersons.add(person);
         }
      }
      return malePersons;
   }
}

class CriteriaFemale implements Criteria {
   @Override
   public List<Person> meetCriteria(List<Person> persons) {
      List<Person> femalePersons = new ArrayList<Person>();
      for (Person person : persons) {
         if (person.getGender().equalsIgnoreCase("Female")) {
            femalePersons.add(person);
         }
      }
      return femalePersons;
   }
}

class CriteriaSingle implements Criteria {
   @Override
   public List<Person> meetCriteria(List<Person> persons) {
      List<Person> singlePersons = new ArrayList<Person>();
      for (Person person : persons) {
         if (person.getMaritalStatus().equalsIgnoreCase("Single")) {
            singlePersons.add(person);
         }
      }
      return singlePersons;
   }
}

class AndCriteria implements Criteria {
   private Criteria criteria;
   private Criteria otherCriteria;

   public AndCriteria(Criteria criteria, Criteria otherCriteria) {
      this.criteria = criteria;
      this.otherCriteria = otherCriteria;
   }

   @Override
   public List<Person> meetCriteria(List<Person> persons) {
      List<Person> firstCriteriaPersons = criteria.meetCriteria(persons);
      return otherCriteria.meetCriteria(firstCriteriaPersons);
   }
}

class OrCriteria implements Criteria {
   private Criteria criteria;
   private Criteria otherCriteria;

   public OrCriteria(Criteria criteria, Criteria otherCriteria) {
      this.criteria = criteria;
      this.otherCriteria = otherCriteria;
   }

   @Override
   public List<Person> meetCriteria(List<Person> persons) {
      List<Person> firstCriteriaItems = criteria.meetCriteria(persons);
      List<Person> otherCriteriaItems = otherCriteria.meetCriteria(persons);

      for (Person person : otherCriteriaItems) {
         if (!firstCriteriaItems.contains(person)) {
            firstCriteriaItems.add(person);
         }
      }
      return firstCriteriaItems;
   }
}

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 class CriteriaPatternExample {
   public static void main(String[] args) {
      List<Person> persons = new ArrayList<Person>();

      persons.add(new Person("Benny", "Male", "Single"));
      persons.add(new Person("Johnny", "Male", "Married"));
      persons.add(new Person("Anna", "Female", "Married"));
      persons.add(new Person("Emma", "Female", "Single"));
      persons.add(new Person("Michael", "Male", "Single"));
      persons.add(new Person("Anthony", "Male", "Single"));

      Criteria male = new CriteriaMale();
      Criteria female = new CriteriaFemale();
      Criteria single = new CriteriaSingle();
      Criteria singleMale = new AndCriteria(single, male);
      Criteria singleOrFemale = new OrCriteria(single, female);

      System.out.println("Males: ");
      printPersons(male.meetCriteria(persons));

      System.out.println("\nFemales: ");
      printPersons(female.meetCriteria(persons));

      System.out.println("\nSingle Males: ");
      printPersons(singleMale.meetCriteria(persons));

      System.out.println("\nSingle Or Females: ");
      printPersons(singleOrFemale.meetCriteria(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() + " ]");
      }
   }
}

输出

输出结果验证了根据不同的条件及其组合进行过滤的正确性，从而显示出所需的人员子集。

Males: 
Person : [ Name : Benny, Gender : Male, Marital Status : Single ]
Person : [ Name : Johnny, Gender : Male, Marital Status : Married ]
Person : [ Name : Michael, Gender : Male, Marital Status : Single ]
Person : [ Name : Anthony, Gender : Male, Marital Status : Single ]

Females: 
Person : [ Name : Anna, Gender : Female, Marital Status : Married ]
Person : [ Name : Emma, Gender : Female, Marital Status : Single ]

Single Males: 
Person : [ Name : Benny, Gender : Male, Marital Status : Single ]
Person : [ Name : Michael, Gender : Male, Marital Status : Single ]
Person : [ Name : Anthony, Gender : Male, Marital Status : Single ]

Single Or Females: 
Person : [ Name : Benny, Gender : Male, Marital Status : Single ]
Person : [ Name : Emma, Gender : Female, Marital Status : Single ]
Person : [ Name : Michael, Gender : Male, Marital Status : Single ]
Person : [ Name : Anthony, Gender : Male, Marital Status : Single ]
Person : [ Name : Anna, Gender : Female, Marital Status : Married ]