jdk 自带的函数式接口以及自定义函数式接口

1、jdk自带的函数式接口

1.1 Predicate

断定型接口

Predicate 函数式接口特点：Predicate调用test方法的时候传一个参数，返回一个布尔值。

    public static boolean isNullOrEmpty(Map map) {


//        Predicate predicate = new Predicate<Map>() {
//            public boolean test(Map map){
//                if (null == map || 0 == map.size()) {
//                    System.out.println("map 的 size is 0");
//                    return true;
//                } else {
//                    return false;
//                }
//            };
//
//        };
         //这里需要指定范型，这里是Map，指定好了范型后，方法里面才能用Map对象的方法
       Predicate<Map> predicate = (map1)->{
            if (null == map1 || 0 == map1.size()) {
                System.out.println("map 的 size is 0");
                return true;
            } else {
                return false;
            }
        };
        return predicate.test(map);

    }



    Map map = new HashMap();
    //使用predicate方法
    boolean flag1 = LogicUtil.isNullOrEmpty(map);

1.2 Consumer

消费型接口

Consumer 函数式接口特点：传一个参数没有返回值，只是消费

/**
 *
 *  消费型接口 只有输入 没有返回值
 *
 */
public class ConsumerInterfaceDemo {

    private static List strings = new ArrayList();
    public static void main(String[] args) {
        Consumer consumer = new Consumer<List>() {
            @Override
            public void accept(List strings) {
               strings.add("gaohq");
               strings.add("2343");

            }
        };

        consumer.accept(strings);

        //list的forEach方法需要传一个Consumer接口，lambda表达式就返回的是一个Consumer 对象。
        //foreach 方法里面会调用accept方法
//        strings.forEach((str)->{
//            System.out.println(str);
//        });

        strings.forEach(new Consumer<String>() {
            @Override
            public void accept(String  o) {
                System.out.println(o);
            }
        });


        System.out.println("==================");

//        Consumer<Integer> consumer1 = (num1)->{
//            System.out.println(num1);
//
//        };

        Supplier supplier = ()->{return 123;};
        Supplier supplier1 = ()->{return 234;};

        List list = new ArrayList();
        list.add(122);
        list.add(987);

        list.add(supplier.get());
        list.add(supplier1.get());


        list.forEach((num1)->{System.out.println(num1);});
    }
}

 

1.3 Function 

Function 函数式接口特点：Function 接口调用apply的时候需要传一个参数，然后返回另一个值

public class VUtil {
    private final static Logger logger = LoggerFactory.getLogger(VUtil.class);

    public static Function<String, Response> isTrue(String id){

//        Function<String, Response> function = (str)->{
//            Response response = new Response();
//            Message message = new Message();
//            boolean flag = LogicUtil.isDayu2(id);
//            if(flag){
//                message.setCode("0001");
//                message.setMessage(str);
//                response.setMessage(message);
//                response.setStatus(Status.FAIL);
//                logger.error("出现了异常 异常  is {}",str);
//                return response;
//            }else {
//                message.setCode("1000");
//                message.setDescription("rpc调用成功!");
//                User user = new User();
//                user.setAge(18);
//                user.setUsername("gaohq");
//                response.setStatus(Status.SUCCESS);
//                response.setMessage(message);
//                response.setData(user);
//                return response;
//            }
//        };
//        return function;

        Function function = new Function<String, Response>() {
            @Override
            public Response apply(String errormsg) {
                Response response = new Response();
                Message message = new Message();
                boolean flag = LogicUtil.isDayu2(id);
                if(flag){
                    message.setCode("0001");
                    message.setMessage(errormsg);
                    response.setMessage(message);
                    response.setStatus(Status.FAIL);
                    logger.error("出现了异常 异常  is {}",errormsg);
                    return response;
                }else {
                    message.setCode("1000");
                    message.setDescription("rpc调用成功!");
                    User user = new User();
                    user.setAge(18);
                    user.setUsername("gaohq");
                    response.setStatus(Status.SUCCESS);
                    response.setMessage(message);
                    response.setData(user);
                    return response;
                }
            }
        };
        return function;
    };

}

//function 函数构造和调用apply方法
Response response = VUtil.isTrue(id).apply("传的参数不能大于 2");

 

1.4 Supplier

供给型接口

Supplier函数式接口特点：Supplier调用get方法的时候，不需要传参数，就能返回一个值

    public static Boolean getTrue(){
//        Supplier supplier = new Supplier<Boolean>() {
//            @Override
//            public Boolean get() {
//                return true;
//            }
//        };
//        return (boolean) supplier.get();


        Supplier<Boolean> supplier = ()->{
            return true;
        };
        return supplier.get();
    }

   //supplier 接口的调用
   if(LogicUtil.getTrue());
        throw new RuntimeException("ceshi  stderr 的问题");
    }

 1.5 Runnale 

Runable 函数式接口特点：Runable调用run方法的不需要参数没有返回值

2、自定义函数式接口

@FunctionalInterface
public interface BranchHandle {

    /**
     * 分支操作
     *
     * @param trueHandle 为true时要进行的操作
     * @param falseHandle 为false时要进行的操作
     * @return void
     **/
    void trueOrFalseHandle(Runnable trueHandle, Runnable falseHandle);


}



/**
 * 参数为true或false时，分别进行不同的操作
 *
 * @param b
 * @return com.example.demo.func.BranchHandle
 **/
private static BranchHandle isTureOrFalse(boolean b){
    return (trueHandle, falseHandle) -> {
        if (b){
           trueHandle.run();
        } else {
           falseHandle.run();
        }
    };


public static Function<String, Response> getResponse(String id){

    boolean flag = LogicUtil.isDayu2(id);
    Response response = new Response();
    Message message = new Message();
    Function function = new Function<String, Response>() {

        @Override
        public Response apply(String errormsg) {
            BranchHandle branchHandle = isTureOrFalse(flag);
            //这个接口需要传两个runable接口，第一个new了一个Runnable接口重写了run方法。
            //trueOrFalseHandle 这个方法里面需要执行Runnable 的run 方法
            //这样我们自定义的run方法就被执行了。
            branchHandle.trueOrFalseHandle(
            new Runnable() {
                @Override
                public void run() {
                    message.setCode("0001");
                    message.setMessage(errormsg);
                    response.setMessage(message);
                    response.setStatus(Status.FAIL);
                    logger.error("出现了异常 异常  is {}",errormsg);
                }

            },()->{
                message.setCode("1000");
                message.setDescription("rpc调用成功!");
                User user = new User();
                user.setAge(18);
                user.setUsername("gaohq");
                response.setStatus(Status.SUCCESS);
                response.setMessage(message);
                response.setData(user);

            });
            return response;
        }
    };

    return function;
}