java11 实现函数式编程的特征

---

    java8里面增加了java.util.function.Function和lambda
有了这两个东东 就可以 实现函数式编程的特征了。函数作为变量，高阶函数，匿名函数，内部函数，柯里化 都能搞定。

直接上代码：

import java.util.List;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.function.Function;
import java.util.stream.Collectors;

public class FuncDemo {

    //--功能函数1
    public static String myFun1(String a){
        return a + "myFun1";
    }

    //--功能函数2
    public static String myFun2(String a){
        return a + "myFun2";
    }

    //--高阶函数,可以吧其他函数作为参数
    public static String myFun(String a,Function function){
        String b = a+"myFun";
        return function.apply(b);
    }

    //内部函数的示例
    public static int testInnerFunc(int a){
        Function tmpAbs =
                x -> {
                    if(x<0){
                        return -1*x;
                    }
                    else{
                        return x;
                    }
                };

        System.out.println(tmpAbs.apply(a));
        return tmpAbs.apply(a);
    }

    //--高阶函数,使用泛型，可以吧其他函数作为参数
    public static  R myFunFanxin(T a,Function function){
        T b = (T)(a+"myFun");
        return function.apply(b);
    }

    //--柯里化，函数返回一个函数，并保存状态
    public static Function myFunZ(String a){
        String b = a+"myFunZ";
        return x-> b + x;
    }

    //--柯里化，函数返回一个复杂函数，并保存状态
    public static Function myFunZex(String a){
        String b = a+"myFunZ";
        return x-> {
                    String tmp = b + x;
                    return tmp + " zz ";
                };
    }

    public static void main(String[] args) throws Exception {
        
        //--将函数放到map里面
        Map> mapFunc = new ConcurrentHashMap>();
        mapFunc.put("func1",x->myFun1(x));
        mapFunc.put("func2",x->myFun2(x));

        //直接传入
        System.out.println(myFun("hello",x->myFun1(x)));

        System.out.println(myFun("hello",x->{
                                    String ha = " haahaha ";
                                    return myFun1(x+ha);
                                })
                    );

        //直接传入,泛型函数
        System.out.println(myFunFanxin("hello",(Function)(x->myFun1(x))));
        //从map取出来
        System.out.println(myFun("hello",mapFunc.get("func2")));
        //匿名函数穿入
        System.out.println(myFun("hello",System.out.println(myFun("hello", x-> {
                                        return x + "myFunZz";
                                }
                ));

        //函数返回一个函数，并调用
        System.out.println(myFunZ("aa").apply("bb"));

    }

}