Java lamda表达式 Predicate<T>、BiFunction<T,T,R>、FunctionalInterface 应用实例说明

使用相对应的 函数式接口，可使编写程序在某些时候变得更高雅和灵活，下面对各种情况进行说明

ps:核心原理就是 将方法作为一个参数传到另一个方法，使该方法处理内容更丰富和灵活，在C#概念中称为 委托。

一、Predicate<T>

特点：只能接收一个参数，返回值固定是 boolean值

1.1 定义方法

 /**
     * 接收执行 predicate 表达式
     * @param predicateLamda
     * @param str
     * @return
     */
    public  static boolean checkString(Predicate<String> predicateLamda,String str){
        return predicateLamda.test(str);
    }

1.2 使用定义 Predicate<String> 方法

public static void main(String[] args) {
        // predicate 表达式
       boolean result1= checkString(str->str.equals("liyanbo"), "woshi liyanbo");
        System.out.println("result1 = " + result1);
}

二、BiFunction<T,T,R>固定  定义两个入参，并有一个返回值

2.1定义  BiFunction<T,T,R>

 /**
     * BiFunction  两个传入参数，一个返回参数
     * @param biFunction
     * @param firstName
     * @param secondName
     * @return
     */
    public  static  Integer getBiFunction(BiFunction<String,String,Integer> biFunction,String firstName,String secondName){
        //String handleName= biFunction.apply(firstName,secondName);// 处理完这个后还可以 有其它逻辑处理
        Integer handleName= biFunction.apply(firstName,secondName);// 处理完这个后还可以 有其它逻辑处理
        return  handleName+1;
    }

2.2 使用定义BiFunction<T,T,R>

    public static void main(String[] args) {    //BiFunction  两个传入参数，一个返回参数
//        BiFunction<String, String, String> biFunction = (firstName, lastName) -> firstName + " " + lastName;
//        String fullName = biFunction.apply("Bill","John");
        Integer fullName=getBiFunction((firstName, lastName) -> (firstName + " " + lastName).length(),"li","yanbo");
        System.out.println(fullName);     
    }

三、FunctionalInterface  接口中仅有一个方法，可随意定义多个参数和有无反会值 

3.1 首先定义一个 仅有一个方法的接口， 接口里 可以定义default 已实现的方法

package com.multiplethread.multiplethread;

@FunctionalInterface
public interface FunctionInterfaceRealize {
    public  String  getHandleResult(Integer l,Integer p);
}

3.2 定义使用 该FunctionInterface 的方法备后续使用 类似 1.1和2.1

 /**
     * 调用 functionInterface 函数式接口
     * @param functionInterfaceRealize
     * @param arg1
     * @param arg2
     * @return
     */
    public static  String getFunctionInterFace(FunctionInterfaceRealize functionInterfaceRealize,Integer arg1,Integer arg2){
         String handleResult= functionInterfaceRealize.getHandleResult(arg1,arg2);

         handleResult=handleResult+"123";
         return  handleResult;
    }

3.3 使用 已定义可以将方法作为参数的方法

 public static void main(String[] args) {     
        // 定义 functionInterFace ,并做相应的逻辑处理
        String handleResult=getFunctionInterFace((x,y)->(x.toString()+y.toString()),1,2);
    }

到此将 方法作为参数的几种情况就说完了，如果有疑问可以评论，大家一起讨论一下。