过滤器方式

过滤器格局:过滤器情势(Filter Pattern)或正规方式(Criteria
Pattern)是1种设计方式,

Java Filter Pattern(过滤器格局)

过滤器形式(Filter Pattern)或正规形式(Criteria
帕特tern)是1种设计情势,这种格局允许开拓职员使用差别的正规化来过滤一组对象,通过逻辑运算以解耦的格局把它们连接起来。那种类型的设计方式属于结构型情势,它构成八个标准来获取纯粹标准。

  1. 开创一个类,在此类上应用规范。

/**
 * 1. 创建一个类,在该类上应用标准。
 * @author mazaiting
 */
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;
    }   
}
  1. 为专门的学问(Criteria)制造3个接口。

/**
 * 2. 为标准(Criteria)创建一个接口
 * @author mazaiting
 */
public interface Critertia {
    /**男性*/
    public static final String MALE = "MALE";
    /**女性*/
    public static final String FEMALE = "FEMALE";
    /**单身*/
    public static final String SINGLE = "SINGLE";

    /**
     * 获取指定的人群
     * @param persons
     */
    public List<Person> meetCriteria(List<Person> persons);
}
  1. 始建达成了 Criteria 接口的实体类。

/**
 * 3. 创建实现了 Criteria 接口的实体类--过滤男性。
 * @author mazaiting
 */
public class CriteriaMale implements Critertia{

    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;
    }

}

/**
 * 3. 创建实现了 Criteria 接口的实体类。--过滤女性
 * @author mazaiting
 */
public class CriteriaFemale implements Critertia{

    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;
    }

}

/**
 * 3. 创建实现了 Criteria 接口的实体类。--过滤单身
 * @author mazaiting
 */
public class CriteriaSingle implements Critertia{

    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;
    }

}

/**
 * 3. 创建实现了 Criteria 接口的实体类。--双重过滤
 * @author mazaiting
 */
public class AndCriteria implements Critertia{

    private Critertia critertia;
    private Critertia otherCritertia;

    public AndCriteria(Critertia critertia, Critertia otherCriteria) {
        this.critertia = critertia;
        this.otherCritertia = otherCriteria;
    }

    public List<Person> meetCriteria(List<Person> persons) {
        List<Person> firstCriteriaPersons = critertia.meetCriteria(persons);
        return otherCritertia.meetCriteria(firstCriteriaPersons);
    }

}

/**
 * 3. 创建实现了 Criteria 接口的实体类。--或过滤
 * @author mazaiting
 */
public class OrCriteria implements Critertia{

    private Critertia critertia;
    private Critertia otherCritertia;

    public OrCriteria(Critertia critertia, Critertia otherCritertia) {
        this.critertia = critertia;
        this.otherCritertia = otherCritertia;
    }

    public List<Person> meetCriteria(List<Person> persons) {
        List<Person> firstCriteriaItems = critertia.meetCriteria(persons);
        List<Person> otherCriteriaItems = otherCritertia.meetCriteria(persons);

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

        return firstCriteriaItems;
    }

}
  1. 主函数验证

public class Client {
    public static void main(String[] args) {
        List<Person> persons = new ArrayList<Person>();

        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"));

        Critertia male = new CriteriaMale();
        Critertia single = new CriteriaSingle();
        Critertia critertia = new AndCriteria(male, single);

        List<Person> meetCriteria = critertia.meetCriteria(persons);
        printPersons(meetCriteria);

    }

    /**
     * 打印数据
     * @param 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()
                +" ]");
          }
       } 
}
  1. 打字与印刷结果

Person : [ Name : Robert, Gender : Male, Marital Status : Single ]
Person : [ Name : Mike, Gender : Male, Marital Status : Single ]
Person : [ Name : Bobby, Gender : Male, Marital Status : Single ]

定义

过滤器情势(Filter Pattern)或正式方式(Criteria
帕特tern)是1种设计格局,这种情势允许开拓职员使用差异的正儿8经来过滤壹组对象,通过逻辑运算以解耦的不二等秘书籍把它们连接起来。那种类型的设计情势属于结构型方式,它构成七个正式来获取纯粹标准。

这种形式允许开采职员使用不一致的标准来过滤1组对象,通过逻辑运算以解耦的章程把它们连接起来。

实现

咱俩将开创二个 Person 对象、Criteria
接口和达成了该接口的实体类,来过滤 Person
对象的列表。CriteriaPatternDemo,大家的身体力行类应用 Criteria
对象,基于种种规范和它们的结合来过滤 Person 对象的列表。

图片 1

过滤器情势的 UML 图

步骤 1
创建一个类,在该类上应用标准。
Person.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;
   }    
}
步骤 2
为标准(Criteria)创建一个接口。
Criteria.java
import java.util.List;

public interface Criteria {
   public List<Person> meetCriteria(List<Person> persons);
}
步骤 3
创建实现了 Criteria 接口的实体类。
CriteriaMale.java
import java.util.ArrayList;
import java.util.List;

public 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;
   }
}
CriteriaFemale.java
import java.util.ArrayList;
import java.util.List;

public 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;
   }
}
CriteriaSingle.java
import java.util.ArrayList;
import java.util.List;

public 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;
   }
}
AndCriteria.java
import java.util.List;

public 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);
   }
}
OrCriteria.java
import java.util.List;

public 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;
   }
}
步骤4
使用不同的标准(Criteria)和它们的结合来过滤 Person 对象的列表。
CriteriaPatternDemo.java
import java.util.ArrayList; 
import java.util.List;

public class CriteriaPatternDemo {
   public static void main(String[] args) {
      List<Person> persons = new ArrayList<Person>();

      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"));

      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()
            +" ]");
      }
   }      
}
步骤 5
验证输出。
Males: 
Person : [ Name : Robert, Gender : Male, Marital Status : Single ]
Person : [ Name : John, Gender : Male, Marital Status : Married ]
Person : [ Name : Mike, Gender : Male, Marital Status : Single ]
Person : [ Name : Bobby, Gender : Male, Marital Status : Single ]

Females: 
Person : [ Name : Laura, Gender : Female, Marital Status : Married ]
Person : [ Name : Diana, Gender : Female, Marital Status : Single ]

Single Males: 
Person : [ Name : Robert, Gender : Male, Marital Status : Single ]
Person : [ Name : Mike, Gender : Male, Marital Status : Single ]
Person : [ Name : Bobby, Gender : Male, Marital Status : Single ]

Single Or Females: 
Person : [ Name : Robert, Gender : Male, Marital Status : Single ]
Person : [ Name : Diana, Gender : Female, Marital Status : Single ]
Person : [ Name : Mike, Gender : Male, Marital Status : Single ]
Person : [ Name : Bobby, Gender : Male, Marital Status : Single ]
Person : [ Name : Laura, Gender : Female, Marital Status : Married ]
```

那连串型的设计格局属于结构型方式,它构成多个正式来获得纯粹规范。

实现:

我们将创建一个 Person 对象、Criteria 接口和实现了该接口的实体类,来过滤 Person 对象的列表。

CriteriaPatternDemo,我们的演示类使用 Criteria 对象,基于各种标准和它们的结合来过滤 Person 对象的列表。

 

代码:

步骤 1

创建一个类,在该类上应用标准。

Person.java

package filterpattern;

 

/**

 * 创建一个类,在该类上应用标准。

 * @author 逆風〠飛翔

 *

 */

public class Person {

     

      private String name;//名字

      private String gender;//性别

      private String maritalStatus;//红色斜体状态

    

      /**

       * 带参构造函数

       * @param name

       * @param gender

       * @param 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;

      } 

   }

步骤 2

为标准(Criteria)创建一个接口。

Criteria.java

import java.util.List;

/**

 * 为标准(Criteria)创建一个接口

 * @author 逆風〠飛翔

 *

 */

public interface Criteria {

   public List<Person> meetCriteria(List<Person> persons);

}

步骤 3

创建实现了 Criteria 接口的实体类。

CriteriaMale.java

import java.util.ArrayList;

import java.util.List;

 

/**

 * 创建实现了Criteria接口的实现类

 * (标准男士)

 * @author 逆風〠飛翔

 *

 */

public 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("男")){

            malePersons.add(person);

         }

      }

      return malePersons;

   }

}

CriteriaFemale.java

import java.util.ArrayList;

import java.util.List;

 /**

  * 创建实现了Criteria接口的实现类

  * (标准女士)

  * @author 逆風〠飛翔

  *

  */

public 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("女")){

            femalePersons.add(person);

         }

      }

      return femalePersons;

   }

}

CriteriaSingle.java

import java.util.ArrayList;

import java.util.List;

/**

 * 创建实现了Criteria接口的实现类

 * 标准单身

 * @author 逆風〠飛翔

 *

 */

public 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("单身")){

            singlePersons.add(person);

         }

      }

      return singlePersons;

   }

}

AndCriteria.java

import java.util.List;

/**

 * 创建实现了Criteria接口的实现类

 * 最终标准

 * @author 逆風〠飛翔

 *

 */

public 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);

   }

}

OrCriteria.java

import java.util.List;

 

public 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;

   }

}

步骤4

使用不同的标准(Criteria)和它们的结合来过滤 Person 对象的列表。

CriteriaPatternDemo.java

import java.util.ArrayList;

import java.util.List;

/**

 * 使用不同的标准(Criteria)和它们的结合来过滤 Person 对象的列表。

 * @author 逆風〠飛翔

 *

 */

public class CriteriaPatternDemo {

   public static void main(String[] args) {

      List<Person> persons = new ArrayList<Person>();

 

      persons.add(new Person("Robert","男", "单身"));

      persons.add(new Person("John","男", "已婚"));

      persons.add(new Person("Laura","女", "已婚"));

      persons.add(new Person("Diana","女", "单身"));

      persons.add(new Person("Mike","男", "单身"));

      persons.add(new Person("Bobby","男", "单身"));

 

      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("女士: ");

      printPersons(male.meetCriteria(persons));

 

      System.out.println("\n男士: ");

      printPersons(female.meetCriteria(persons));

 

      System.out.println("\n单身女士: ");

      printPersons(singleMale.meetCriteria(persons));

 

      System.out.println("\n单身并且是女士: ");

      printPersons(singleOrFemale.meetCriteria(persons));

   }

 

   public static void printPersons(List<Person> persons){

      for (Person person : persons) {

         System.out.println("Person : [ 名字 : " + person.getName()

            +", 性别 : " + person.getGender()

            +",婚姻状况 : " + person.getMaritalStatus()

            +" ]");

      }

   }     

}

步骤 5

执行程序,输出结果:

女士:

Person : [ 名字 : Robert, 性别 : 男,婚姻状况 : 单身 ]

Person : [ 名字 : John, 性别 : 男,婚姻状况 : 已婚 ]

Person : [ 名字 : Mike, 性别 : 男,婚姻状况 : 单身 ]

Person : [ 名字 : Bobby, 性别 : 男,婚姻状况 : 单身 ]

 

男士:

Person : [ 名字 : Laura, 性别 : 女,婚姻状况 : 已婚 ]

Person : [ 名字 : Diana, 性别 : 女,婚姻状况 : 单身 ]

 

单身女士:

Person : [ 名字 : Robert, 性别 : 男,婚姻状况 : 单身 ]

Person : [ 名字 : Mike, 性别 : 男,婚姻状况 : 单身 ]

Person : [ 名字 : Bobby, 性别 : 男,婚姻状况 : 单身 ]

 

单身并且是女士:

Person : [ 名字 : Robert, 性别 : 男,婚姻状况 : 单身 ]

Person : [ 名字 : Diana, 性别 : 女,婚姻状况 : 单身 ]

Person : [ 名字 : Mike, 性别 : 男,婚姻状况 : 单身 ]

Person : [ 名字 : Bobby, 性别 : 男,婚姻状况 : 单身 ]

Person : [ 名字 : Laura, 性别 : 女,婚姻状况 : 已婚 ]

Post Author: admin

发表评论

电子邮件地址不会被公开。 必填项已用*标注