Java中 使用Lambda表达式实现函数式编程中的柯里化和部分应用

何使用Lambda表达式实现函数式编程中的柯里化（Currying）

柯里化（Currying）是一种在函数式编程中常见的技术，它把一个接受多个参数的函数转换成一系列使用一个参数的函数。在Java中，由于Lambda表达式的引入和函数式接口的广泛应用，实现柯里化变得相对简单。

在Java中，要实现柯里化，通常需要定义一个返回函数的函数。这可以通过使用Lambda表达式和函数式接口来实现。下面是一个使用Java的Lambda表达式实现柯里化的例子：

首先，定义一个函数式接口，用于表示接受一个参数并返回结果的函数：

@FunctionalInterface
interface CurriedFunction<A, B> {
    B apply(A a);
}

然后，实现一个柯里化方法，该方法接受一个二元函数（接受两个参数的函数）并返回一个柯里化后的函数：

public class CurryingExample {

    // 二元函数接口
    @FunctionalInterface
    interface BinaryFunction<A, B, C> {
        C apply(A a, B b);
    }

    // 柯里化方法
    public static <A, B, C> CurriedFunction<A, CurriedFunction<B, C>> curry(BinaryFunction<A, B, C> binaryFunction) {
        return a -> b -> binaryFunction.apply(a, b);
    }

    public static void main(String[] args) {
        // 定义一个二元函数，比如加法
        BinaryFunction<Integer, Integer, Integer> add = (x, y) -> x + y;

        // 使用柯里化方法
        CurriedFunction<Integer, CurriedFunction<Integer, Integer>> curriedAdd = curry(add);

        // 使用柯里化后的函数
        CurriedFunction<Integer, Integer> fixedFirstArgAdd = curriedAdd.apply(5); // 固定第一个参数为5
        int result = fixedFirstArgAdd.apply(3); // 调用固定了第一个参数的函数，第二个参数为3

        System.out.println(result); // 输出：8，因为5 + 3 = 8
    }
}

在上面的代码中，curry 方法接受一个二元函数作为参数，并返回一个新的函数，这个新函数接受第一个参数并返回另一个函数，这个返回的函数接受第二个参数并应用原始的二元函数。这样，原始函数就被“柯里化”了，可以分步接收参数。

在main方法中，我们定义了一个简单的加法函数add，然后使用curry方法将其柯里化。接着，我们固定了第一个参数为5，得到了一个新的函数fixedFirstArgAdd。最后，我们调用这个新函数并传入第二个参数3，得到了最终的结果8。

通过使用Lambda表达式和函数式接口，Java可以相对容易地实现函数式编程中的柯里化技术，从而增强代码的灵活性和可复用性。

如何使用Lambda表达式实现函数式编程中的部分应用（Partial Application）

在函数式编程中，部分应用（Partial Application）是指固定一个或多个函数参数的值，从而创建一个新的函数的过程。这个新的函数将原先函数未固定的参数作为自己的参数。在Java中，你可以使用Lambda表达式结合方法引用来实现部分应用。

Java 8引入了函数式接口（Functional Interfaces），这使得Lambda表达式的使用变得非常方便。函数式接口是只有一个抽象方法的接口，你可以使用Lambda表达式来实例化这样的接口。

以下是如何使用Lambda表达式实现部分应用的一个例子：

import java.util.function.Function;

public class PartialApplicationExample {

    public static void main(String[] args) {
        // 定义一个函数，它接受两个参数并返回它们的和
        Function<Integer, Function<Integer, Integer>> addFunction = 
            a -> b -> a + b;

        // 使用部分应用来固定第一个参数为5
        Function<Integer, Integer> addFive = addFunction.apply(5);

        // 现在，addFive是一个新函数，它接受一个参数并返回5与这个参数的和
        System.out.println(addFive.apply(3)); // 输出 8

        // 同样，我们可以固定第二个参数为10
        Function<Integer, Integer> addToTen = a -> addFunction.apply(a).apply(10);

        // addToTen也是一个新函数，它接受一个参数并返回这个参数与10的和
        System.out.println(addToTen.apply(7)); // 输出 17
    }
}

在这个例子中，我们定义了一个函数addFunction，它接受两个Integer参数并返回它们的和。然后，我们使用apply方法来部分应用这个函数，固定第一个参数为5，从而创建一个新的函数addFive。同样地，我们也创建了一个新函数addToTen，它固定了第二个参数为10。

通过使用Lambda表达式和方法引用，我们可以轻松地实现函数的部分应用，并且创建出更加灵活和可复用的函数。这在函数式编程中是一个常见的模式，它有助于减少代码重复，提高代码的可读性和可维护性。