09 过滤器模式

过滤器模式

用来过滤数据，通过一个或多个定义过滤规则，窜起来过滤原始数据。

demo

package structuralpattern;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.Collectors;

/**
 * @author tx
 * @version 1.0
 * @date 2024/1/8 9:00
 * @description:
 * 过滤器模式
 * 用以筛选数据
 */
public class FilterPattern {
    /**
     * 打印list,方便展示
     */
    public static <T> void printList(List<T> list){
        System.out.println("[");
        for (T one : list) {
            System.out.println(one.toString());
        }
        System.out.println("]");
    }
    public static void main(String[] args) {
        // 过滤器创建
        Filter filter1 = new Filter1();
        Filter filter2 = new Filter2();
        Filter3 filter3 = new Filter3();
        // 构造假数据
        List<Product> products = new ArrayList<>();
        for (int i = 0; i < 5; i++) {
            products.add(new Product("张"+i, (int) Math.round(Math.random()*20)));
            products.add(new Product("李"+i, (int) Math.round(Math.random()*20)));
        }
        // 原始数据打印
        System.out.println("原始数据");
        FilterPattern.printList(products);
        // 使用单一过滤器,size 大于5的
        System.out.println("使用单一过滤器,size 大于5的:");
        List<Product> ans1 = filter1.filter(products);
        FilterPattern.printList(ans1);
        // 使用单一过滤器,姓名包含张的
        System.out.println("使用单一过滤器,姓名包含张的:");
        List<Product> ans2 = filter3.filter(products);
        FilterPattern.printList(ans2);
        // 使用组合过滤器，组合上面三种条件
        System.out.println("使用组合过滤器，组合上面三种条件:");
        ArrayList<Filter> filtersArgs = new ArrayList<>();
        filtersArgs.add(filter1);
        filtersArgs.add(filter2);
        filtersArgs.add(filter3);
        Filter filters = new Filters(filtersArgs);
        List<Product> ans3 = filters.filter(products);
        FilterPattern.printList(ans3);

    }
}

/**
 * 组合过滤器
 */
class Filters implements Filter{
    private final List<Filter> filters;
    public Filters(List<Filter> filters) {
        this.filters = filters;
    }
    @Override
    public List<Product> filter(List<Product> products) {
        List<Product> local = products;
        for (Filter filter : filters) {
            local = filter.filter(local);
        }
        return local;
    }
}


/**
 * 过滤器的接口
 */
interface Filter{
    List<Product> filter(List<Product> products);
}
/**
 * 过滤大小大于5的
 */
class Filter1 implements Filter{
    @Override
    public List<Product> filter(List<Product> products) {
        return products.stream()
                .filter(p -> p.size() > 5)
                .collect(Collectors.toList());
    }
}
/**
 * 过滤大小小于15的
 */
class Filter2 implements Filter{
    @Override
    public List<Product> filter(List<Product> products) {
        return products.stream()
                .filter(p -> p.size() <15)
                .collect(Collectors.toList());
    }
}
/**
 * 过滤名字含有 张 的
 */
class Filter3 implements Filter{
    @Override
    public List<Product> filter(List<Product> products) {
        return products.stream()
                .filter(p -> p.name().contains("张"))
                .collect(Collectors.toList());
    }
}

/**
 * 需要被过滤的对象
 */
class Product{
    private String name;
    private Integer size;

    public Product(String name, Integer size) {
        this.name = name;
        this.size = size;
    }

    public String name() {
        return name;
    }

    public Integer size() {
        return size;
    }

    @Override
    public String toString() {
        return "Product{" +
                "name='" + name + '\'' +
                ", size=" + size +
                '}';
    }
}

demo 打印