### 本篇文章带你简单理解函数式编程
话不多说 开始！
- 特性
1.   必须是接口
2.   必须只有唯一一个未实现方法
3.   必须注解@FunctionalInterface声明

---

我们常见的基础函数式接口有 comsumer、function、predicate、supplier、

我们以一台手机的从生产到销售为例，贯穿函数式编程
生产-> 质检 -> 包装 -> 销售

上代码

手机类

@Data
@AllArgsConstructor
public class Phone {

    /**
     * 手机编号
     */
    private Integer code;

    /**
     *  手机名称
     */
    private String name;

    /**
     *  手机质量
     */
    private boolean quality;

    /**
     *  手机版本
     */
    private String version;
}

```

包装类

@Data
@AllArgsConstructor
public class PhoneBox {

    /**
     *  手机
     */
    private Phone phone;

    /**
     * 证书
     */
    private String certificate;
}

生产线

 

public class ProductionLine {

    /**
     *  生产手机
     * @param supplier
     * @return
     */
    public Phone prodPhone(Supplier<Phone> supplier) {
        return supplier.get();
    }

    /**
     * 质量检测
     *
     * @param predicate
     * @param phone
     * @return
     */
    public boolean detection(Predicate<Phone> predicate, Phone phone) {
        return predicate.test(phone);
    }

    /**
     * 包装
     *
     * @param function
     * @param phone
     * @return
     */
    public PhoneBox packaging(Function<Phone, PhoneBox> function, Phone phone) {
        return function.apply(phone);
    }

    /**
     *  销售
     *
     * @param consumer
     * @param phoneBox
     */
    public void sell(Consumer<PhoneBox> consumer, PhoneBox phoneBox) {
        consumer.accept(phoneBox);
    }
}

测试类

```

public class Test {



    @org.junit.Test
    public void phoneLine() {
        ProductionLine productionLine = new ProductionLine();
        //  流水线存在质检和销售， 移除操作  需要使用安全List
        List<Phone> phoneList = new ArrayList<>();

        // 生产手机  Supplier
        for (int i = 0; i < 10; i++) {
            int finalI = i;
            Phone phone = productionLine.prodPhone(() -> {
                System.out.println("生产手机===》编号：" + finalI);
                return new Phone(finalI, "iPhone13", finalI % 2 == 0, "V1.0");
            });
            phoneList.add(phone);
        }

        // 质检  Predicate
        //  Stream质检 phoneList = phoneList.stream().filter(Phone::isQuality).collect(Collectors.toList());
        // 遍历时移除 存在不安全操作, 所以这里使用普通for循环 便于操作List
        for (int i = 0; i < phoneList.size(); i++) {
            if (productionLine.detection(Phone::isQuality, phoneList.get(i))) {
                System.out.println("质检不合格手机===》编号：" + phoneList.get(i).getCode());
                phoneList.remove(i);
            }

        }
        // 包装 stream方式
        // List<PhoneBox> phoneBoxList = phoneList.stream().map(e -> new PhoneBox(e, "安全证书")).collect(Collectors.toList());

        List<PhoneBox> boxList = new ArrayList<>();
        phoneList.forEach(e -> {
            System.out.println("包装手机===》编号：" + e.getCode());
            PhoneBox phoneBox = productionLine.packaging(f -> new PhoneBox(e, "安全证书"), e);
            boxList.add(phoneBox);
        });

        // 销售 Stream方式
        // 遍历时移除 存在不安全操作, 所以这里使用普通for循环 便于操作List
        for (int i = 0; i < boxList.size(); i++) {
            productionLine.sell(f -> {
                System.out.println("卖出手机==》编号：" + f.getPhone().getCode());
            }, boxList.get(i));
        }
    }

}

```

执行结果

生产手机===》编号：0
生产手机===》编号：1
生产手机===》编号：2
生产手机===》编号：3
生产手机===》编号：4
生产手机===》编号：5
生产手机===》编号：6
生产手机===》编号：7
生产手机===》编号：8
生产手机===》编号：9
质检不合格手机===》编号：0
质检不合格手机===》编号：2
质检不合格手机===》编号：4
质检不合格手机===》编号：6
质检不合格手机===》编号：8
包装手机===》编号：1
包装手机===》编号：3
包装手机===》编号：5
包装手机===》编号：7
包装手机===》编号：9
卖出手机==》编号：1
卖出手机==》编号：3
卖出手机==》编号：5
卖出手机==》编号：7
卖出手机==》编号：9