基本介绍：
    1、目的：使用不同的标准来过滤一组对象，通过逻辑运算以解耦的方式把它们连接起来；
    2、实现：制定不同的规则来对一组对象进行过滤，然后对过滤结果进行分组。

    场景举例：
    有一个手机套餐的例子，过滤出符合要求的手机套餐

    代码示例：

    1. /**
    2.  * 客户的手机套餐
    3.  */
    4. @Data
    5. @AllArgsConstructor
    6. @NoArgsConstructor
    7. public class Consumer implements Serializable {
    8.     private static final long serialVersionUID = -2830434210628625159L;
    10.     /**
    11.      * 姓名
    12.      */
    13.     private String name;
    15.     /**
    16.      * 套餐价格
    17.      */
    18.     private Integer price;
    20.     /**
    21.      * 套餐流量
    22.      */
    23.     private Integer flow;
    24. }

    抽象的过滤接口以及接口的两个具体实现类

    1. /**
    2.  * 抽象过滤器接口
    3.  */
    4. public interface Filter {
    6.     /**
    7.      * 过滤筛选出需要的套餐
    8.      * @param consumerList 套餐列表
    9.      * @return 过滤后的套餐列表
    10.      */
    11.     List<Consumer> filterConsumers(List<Consumer> consumerList);
    12. }
    14. /**
    15.  * 流量过滤器
    16.  */
    17. public class FlowFilter implements Filter{
    18.     @Override
    19.     public List<Consumer> filterConsumers(List<Consumer> consumerList) {
    20.         ArrayList<Consumer> consumers = new ArrayList<>();
    21.         for (Consumer consumer : consumerList) {
    22.             //过滤出套餐流量1G以上的
    23.             if (consumer.getFlow()>1000){
    24.                 consumers.add(consumer);
    25.             }
    26.         }
    27.         return consumers;
    28.     }
    29. }
    31. /**
    32.  * 价格过滤器
    33.  */
    34. public class PriceFilter implements Filter{
    35.     @Override
    36.     public List<Consumer> filterConsumers(List<Consumer> consumerList) {
    37.         ArrayList<Consumer> consumers = new ArrayList<>();
    38.         for (Consumer consumer : consumerList) {
    39.             //过滤出套餐价格100以内的
    40.             if (consumer.getPrice()<100){
    41.                 consumers.add(consumer);
    42.             }
    43.         }
    44.         return consumers;
    45.     }
    46. }

    过滤器的调用

    1. public class Client {
    2.     public static void main(String[] args) {
    3.         ArrayList<Consumer> list = new ArrayList<>();
    4.         list.add(new Consumer("PackageOne",38,800));
    5.         list.add(new Consumer("PackageTwo",50,1200));
    6.         list.add(new Consumer("PackageThree",200,2000));
    8.         List<Consumer> consumerList = new FlowFilter().filterConsumers(list);
    9.         System.out.println("流量过滤结果：");
    10.         for (Consumer consumer : consumerList) {
    11.             System.out.println(consumer);
    12.         }
    14.         List<Consumer> priceList = new PriceFilter().filterConsumers(list);
    15.         System.out.println("价格过滤结果：");
    16.         for (Consumer consumer : priceList) {
    17.             System.out.println(consumer);
    18.         }
    19.     }
    20. }

    涉及到的角色：
    1、 AbstractFilter（抽象过滤器角色）：在客户端可以调用它的方法，在抽象过滤器角色中可以知道相关的（一个或者多个）子系统的功能和责任；在正常情况下，它将所有从客户端发来的请求委派到相应的实现类去，传递给相应的实现类对象处理。
    2、 ConcreteFilter（具体滤器角色）：在客户端可以调用它的方法，在具体滤器角色会对目标对象集合进行逻辑过滤，最后再返回一个过滤后的集合。
    3、 Subject（被过滤角色）：在软件系统中可以有一个或者多个目标角色，在具体过滤器中会对目标角色进行逻辑处理以查看是否是我想要的。