函数式接口设计

1.Supplier<T> 接口定义：
基本特点：只出不进
编程范式：作为方法/构造参数、方法返回值
使用场景：数据来源，代码替代接口

代码如下：

public class SupplierDesignDemo {
    public static void main(String[] args) {
        echo("Hello,World");//固定参数

        echo(() ->{//变化实现
            sleep(1000);
            return "Hello,World";
        });
        echo(SupplierDesignDemo::getMessage);

        getMessage();//及时返回数据

        Supplier<String> message = supplyMessage();//待执行数据
        
        message.get();//实际执行
    }

    private static String getMessage(){
        sleep(1000);
        return "Hello,World";
    }

    private static Supplier<String> supplyMessage() {
        return SupplierDesignDemo::getMessage;
    }

    public static void sleep(long millis) {
        try {
            Thread.sleep(millis);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }

    public static void echo(String message) {//拉的模式
        System.out.println(message);
    }

    public static void echo(Supplier<String> message) {//推的模式
        System.out.println(message.get());
    }
}

2.Consumer<T>接口设计：
基本特点：只进不出
编程范式：作为方法/构造参数
使用场景：执行Callback

3.Function<T,R>接口设计：
基本特点：有进有出
编程范式：作为方法/构造参数
使用场景：类型转换，业务处理等

代码如下：

public class FunctionDesignDemo {
    public static void main(String[] args) {

        Function function = a -> a;

        //Function 可以用于同类转换
        Function<Integer,Integer> divide2 = a -> a / 2;
    }
}

4.Predicate<T>接口设计：
基本特点：boolean类型判断
编程范式：作为方法/构造参数 通常不会放到方法返回值中
使用场景：过滤，对象比较等

代码如下：

public class PredicateDesignDemo {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);

        Collection<Integer> even = filter(numbers,num -> num % 2 == 0);

        Collection<Integer> odd = filter(numbers,num -> num % 2 != 0);

        System.out.println(even);

        System.out.println(odd);

        Stream.of(1,2,3,4,5).filter(num -> num % 2 == 0).forEachOrdered(System.out::println);
    }

    private static  <E> Collection <E> filter (Collection <E> source, Predicate <E> predicate) {
        //集合类操作，请不要直接利用参数  少量操作时使用
        List <E> copy = new ArrayList <E>(source);
        Iterator <E> iterator = copy.iterator();
        while (iterator.hasNext()) {
            E element = iterator.next();
            if (!predicate.test(element)) {
                iterator.remove();
            }
        }
        return Collections.unmodifiableList(copy);//保持只读
        
    }
}