用Kotlin和Java玩转函数式编程

最编程 2024-08-04 13:22:51

...

1.Kotlin中使用函数编程

在java中有时候使用函数式编程，我们会定义Producer,Consumer来作为函数的参数，在kotlin中的使用跟java中稍有不同，不需要显式的定义Producer和Conuser，仅仅通过参数和返回值即可，比如如下的函数，函数的参数是一个Lambda表达式：入参是一个Double类型，无返回值；

fun randomProvier(c: (Double) -> Unit): Double {
    var n = Math.random()    //  步骤1：生成随机数
    println("生成随机数")      //  步骤2：
    c(n)                     //  步骤3:随机数n作为参数，执行传入的代码逻辑
    return n                //   步骤4:返回随机数n
}

fun main() {
    randomProvier { t ->
        println("打印随机数参数")  //步骤3.1
        println(t)               //步骤3.1
    }
}

randomProvier的参数是一段执行逻辑，输入参数是一段代码逻辑；整个方法执行顺序：

1>步骤1先生成一个随机数

2>步骤2打印“生成随机数”

3>步骤3，执行lambda表达式，进入步骤3.1，3.2；

4>步骤4，返回随机数n

如果要一个无参数的代码段逻辑，如下这么写就可以：

fun numberPrinter(s: () -> Double){
    println(s())
}

在项目中遇到的一种场景，需要在原来的多个函数执行逻辑前后加一部分逻辑；

比如原来有个函数

fun f1(){
xxxx
xxx
xx
}

现在需要在f1函数执行前加一些逻辑，在执行再加一些逻辑，如果手工添加的话，这样的地方太多，另外还很可能会漏掉，比如只在开头加了一段逻辑，结尾忘记了；可以定义一个方法，

fun main() {
   f2 { f1() }
}

fun f2(c: () -> Unit) {
    println("执行方法之前添加逻辑")
    c()
    println("执行方法后添加逻辑")
}

fun f1(){
    println("原来的逻辑")
}

执行结果输出：

执行方法之前添加逻辑
原来的逻辑
执行方法后添加逻辑

2.Java中使用

在java中要明确是哪种函数编程，常见的有一下几种；
1>Function<T,R> 接受一个输入参数，返回一个结果，常用的方法是apply，

public static void main(String[] args) {
        String a="1123";
        f1(b ->{
            return b+"1";
        },a);
    }

    static void f1(Function<String,String> f2,String a){
        String result = f2.apply(a);
        System.out.println(result);
    }

2>Supplier 无输入参数，返回一个结果，常用的方法是get，返回Supplier的返回值；demo:

Supplier<Integer> supplier = () -> {
    return 1;
};
System.out.println(supplier.get());

3>Consumer 接受一个输入参数，并且不返回任何结果,常用的方法是

accept:接受一个参数作为函数的入参；

andThen：用accept中的参数，先执行第一个consumer，在执行第二个，因为andThen返回结果也是一个Consumer，所以可以无限添加，例如：

consumer.andThen(consumer1).andThen(consumer1).accept(10);

Demo：

public static void main(String[] args) {
        Consumer<Integer> consumer = (x) -> {
            int num = x * 2;
            System.out.println(num);
        };
        Consumer<Integer> consumer1 = (x) -> {
            int num = x * 3;
            System.out.println(num);
        };
        consumer.accept(1);
        consumer.andThen(consumer1).accept(10);
    }

4>Runnable 无参数，无返回结果,demo:

Runnable r = ()->{
    System.out.println("runable");
};
r.run();
其他
5>BiFunction<T,U,R>    接受两个输入参数的方法，并且返回一个结果
BiFunction<Integer, Integer, Integer> biFunction = (x, y) -> {
    return x + y;
};
System.out.println(biFunction.apply(1,2));
6>BiConsumer<T,U>    接受两个输入参数的操作，并且不返回任何结果
BiConsumer<Integer, Integer> biFunction = (x, y) -> {
    System.out.println(x + y);
};
biFunction.accept(1,2);

上一篇：函数式编程

下一篇：秒懂：为什么函数式编程如此热门？

用Kotlin和Java玩转函数式编程

用 Java 8 实现函数式编程和 Lambda 表达式操作 Stream 流

用Kotlin和Java玩转函数式编程

用 Java 8 学习函数式编程