链式编程+流式计算

• 函数式型接口 Function<T,R> 传入一个参数，获取一个返回值
• 断定型接口 Predicate 传入一个参数，返回一个 bool 值
• 消费型接口 Consumer 传入参数，没有返回值
• 供给型接口 Supplier 没有传参数，有返回值

Package java.util.function

/**
 * @author zhangxiao
 * @qq 490433117
 * @create_date 2022/6/13 9:32
 */
package com.xiao.test;

import com.sun.media.jfxmediaimpl.HostUtils;

import java.sql.Connection;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;

/**
 * @author zhangxiao
 * @date 2022/6/13 9:32
 */
public class FunctionTest {
    public static void main(String[] args) {
        // 1.消费型接口，传入一个参数，用来消费，没有返回值
//        consumer(); 
        // 2.函数型接口  传入一个参数，获取一个返回值
//        function();

        // 3.供给型接口  没有参数，有返回值
//        supplier();

        // 4. 断定型接口 传入一个参数，返回一个 bool 值 
        predicate();
    }

    // 断定型接口卡 传入一个参数，返回一个bool值 
    private static void predicate() {
        Predicate<String> predicate = new Predicate<String>() {
            @Override 
            public boolean test(String s) {
                if (s.equals("zhangxiao")){
                    return true;
                }else{
                    return false;
                }
            }
        };

        boolean xx = predicate.test("zhangxiao");
//        System.out.println(xx);

        // 方式2  lambda 
        Predicate<String> predicate1 = (s)->{
            if (s.equals("zhangxiao")){
                return true;
            }else{
                return false;
            }
        };
        boolean xiao = predicate1.test("xiao");
        System.out.println(xiao);

    }

    // 供给型接口  没有参数，有返回值 
    private static void supplier() {
//        方式1 
        Supplier<String> supplier = new Supplier<String>() {
            @Override 
            public String get() {
                return "hello supplier";
            }
        };
        String s = supplier.get();
//        System.out.println(s);

//        方式2 lambda 
        Supplier<String> supplier1 = () -> {
            return "hello supplier lambda";
        };
        String s1 = supplier1.get();
        System.out.println(s1);

    }

    // 函数型接口  传入一个参数，获取一个返回值 
    private static void function() {
//        方式1 
        Function<String, String> function = new Function<String, String>() {
            @Override 
            public String apply(String s) {
                if (s.equals("zhang")) {
                    return "zhangxiao";
                } else {
                    return "error";
                }
            }
        };

        String zh = function.apply("zhang");
//        System.out.println(zh);

//        方式2 lambda 
        Function<String, String> function1 = (x) -> {
            if (x.equals("zhang")) {
                return "zhangxiao";
            } else {
                return "error";
            }
        };

        String er = function1.apply("zhang");
        System.out.println(er);


    }

    // 消费型接口 
    public static void consumer() {
        // 传入一个参数用来消费,没有返回值

        // 方式1 
        Consumer<String> consumer = new Consumer<String>() {
            @Override 
            public void accept(String s) {
                // insert 
                System.out.println(s);
            }
        };

        consumer.accept("zhang");

        // 方式2  lambda 
        Consumer<String> result = (s) -> {
            System.out.println(s);
        };

        result.accept("abc");
    }
}