初识Java 11-1 函数式编程

旧方式与新方式

lambda表达式

方法引用

Runnable

未绑定方法引用

构造器方法引用

函数式接口

带有更多参数的函数式接口

解决缺乏基本类型函数式接口的问题

本笔记参考自：《On Java 中文版》

函数式编程语言的一个特点就是其处理代码片段的简易性，就像处理数据一样简单。Java 8加入的lambda表达式和方法引用为函数式风格编程做出了一定的支持。

在计算机的早期时代，为了让程序能够适应有限的内存，程序员往往需要在程序执行时修改内存中的代码，让程序做出不同的行为，依此节省空间。这就是自修改代码技术。因为彼时的程序大都足够小，因此维护起来并不会太麻烦。

但随着内存的增大，自修改代码被认为是一个糟糕的想法，它极大地增加了程序的维护成本。尽管如此，这种使用代码以某种方式操纵其他代码的想法依旧十分吸引人：通过组合已经经过良好测试的代码，我们可以生产出更有效率、更加安全的代码。

函数式编程的意义就在于此：通过整合现有代码来产生新的功能，而不是从零开始编写所有内容，由此可以得到更加可靠、实现起来更快的代码。

面向对象编程抽象数据，而函数式编程抽象行为。

纯函数式语言在安全方面规定了额外的约束条件，所有的数据必须是不可变的：设置一次，永不改变。此时函数绝对不会修改现有值，而是只生成新值。（纯函数式语言在面对一些问题时能够提出一个好的解决，但这不代表纯函数式语言就是最好的解决方式）

Python等非函数式编程语言已经将函数式编程的概念纳入其中，并且受益匪浅。Java也加入了类似的特性。

旧方式与新方式

通过将代码传递给方法，我们可以控制方法，使其产生出不同的行为。

旧的方式是创建一个对象（在下例中是Strategy），让其的某个方法包含所需行为，在将这个对象传递给我们想要控制的方法：

package functional;

import java.util.Locale;

interface Strategy {
    String approch(String msg);
}

class Soft implements Strategy {
    @Override
    public String approch(String msg) {
        return msg.toLowerCase() + "?";
    }
}

class Unrelated {
    static String twice(String msg) {
        return msg + " " + msg;
    }
}

public class Strategize {
    Strategy strategy;
    String msg;

    Strategize(String msg) {
        strategy = new Soft(); // 将Soft()作为一个默认的决策
        this.msg = msg;
    }

    void communicate() {
        System.out.println(strategy.approch(msg));
    }

    void changeStrategy(Strategy strategy) {
        this.strategy = strategy;
    }

    public static void main(String[] args) {
        Strategy[] strategies = {
                new Strategy() { // 创建一个匿名内部类来改变行为，虽然依旧会有重复的代码
                    @Override
                    public String approch(String msg) {
                        return msg.toUpperCase() + "!";
                    }
                },
                msg -> msg.substring(0, 5), // 这就是Java 8开始提供的lambda表达式
                Unrelated::twice // 这也是Java 8中出现的方法引用
        };

        Strategize s = new Strategize("Hello there");
        s.communicate();
        for (Strategy newStrategy : strategies) {
            s.changeStrategy(newStrategy); // 遍历数组strategies中的每一个决策，并将其放入s中进行决策更换
            s.communicate(); //　更换决策后，每一次输出都会产生不同的结果：我们传递了行为，而被仅仅是数据
        }
    }
}

程序执行的结果是：

Strategy提供的接口包含了唯一的approach()方法。通过创建不同的Strategy对象，就可以创建不同的行为。

在上述程序中，包含了默认的决策Soft()和一个匿名内部类。除此之外，还出现两个了Java 8添加的新内容：

lambda表达式：
```
msg -> msg.substring(0, 5)
```
这种表达式的特点是使用箭头->分隔参数和函数体。
方法引用：
```
Unrelated::twice
```
特点是::。其中，::左边是类名或对象名，右边是方法名，但没有参数列表。

在Java 8之前，使用普通的类或者匿名内部类来传递功能，但这种语法的并不方便。lambda表达式和方法引用改变了这种情况，使得传递功能变得更加便捷。

lambda表达式

||| lambda表达式是使用尽可能少的语法编写的函数定义。

换言之，lambda表达式产生的是函数，而不是方法。当然，Java中的一切都是类，之所以lambda表达式会让人产生这种“错觉”，是因为幕后进行了各种各样的操作。作为程序员，我们可以将lambda表达式视为函数。

lambda表达式的语法宽松，且易于编写。例如：

package functional;

interface Description {
    String brief();
}

interface Body {
    String detailed(String head);
}

interface Multi {
    String twoArg(String head, Double d);
}

public class LambdaExpressions {
    static Body bod = h -> h + "No Parens!"; // 本条语句并不需要使用括号（仅限只有一个参数时）
    static Body bod2 = (h) -> h + "More details"; // 使用了括号。处于一致性的考虑，在只有一个参数时也使用括号
    static Description desc = () -> "Short info"; // 若没有参数，必须使用括号来指示空的参数列表
    static Multi mult = (h, n) -> h + n; // 有多个参数，此时必须将它们放在使用括号包裹的参数列表中

    static Description moreLines = () -> {
        System.out.println("moreLines()");
        return "from moreLines()";
    };

    public static void main(String[] args) {
        System.out.println(bod.detailed("Oh!"));
        System.out.println(bod2.detailed("Hi!"));
        System.out.println(desc.brief());
        System.out.println(mult.twoArg("Pi: ", 3.14159));
        System.out.println(moreLines.brief());
    }
}

程序执行的结果是：

在上述的3个接口中，每个接口都有一个方法（这是后续会提到的函数式接口）。任何lambda表达式的基本语法如下：

注释中提到过，若没有参数，就必须使用括号来指示空的参数列表。

对一行的lambda表达式而言，方法体中表达式的结果会自动成为lambda表达式的返回值，所以这里使用return关键字是不和法的。另外，若lambda表达式需要多行代码，如上文中的moreLines，就需要将表达式的代码放入到花括号中。此时又会需要使用return从lambda表达式中生成一个值了。

可以看到，lambda表达式可以通过接口更方便地生成行为不同的对象。

递归

递归，即函数调用了自身。Java也允许编写递归的lambda表达式，但需要注意一点：这个lambda表达式必须被赋值给一个静态变量或一个实例变量。通过两个示例说明这些情况：

两个示例会使用一个相同的接口：

interface IntCall {
    int call(int arg);
}

【示例：静态变量】实现一个阶乘函数，递归计算小于等于n的正整数的乘积：

public class RecursiveFactorial {
    static IntCall fact;

    public static void main(String[] args) {
        fact = n -> n == 0 ? 1 : n * fact.call(n - 1);
        for (int i = 0; i <= 10; i++)
            System.out.println(fact.call(i));
    }
}

程序执行的结果是：

在这个例子中，fact就是一个静态变量。递归函数会不断调用其自身，因此必须有某种停止条件（在上述例子中是n == 0），否则就会陷入无限递归，直到栈空间被耗尽。

下方这种初始化fact的方式是不被允许的：

static IntCall fact = n -> n == 0 ? 1 : n * fact.call(n - 1);

这种处理对Java编译器而言还是太过复杂了，会导致编译错误。

---

【示例：示例变量】实现斐波那契数列：

public class RecursiveFibonacci {
    IntCall fib;

    RecursiveFibonacci() {
        fib = n -> n == 0 ? 0 :
                n == 1 ? 1 :
                        fib.call(n - 1) + fib.call(n - 2);
    }

    int fibonacci(int n) {
        return fib.call(n);
    }

    public static void main(String[] args) {
        RecursiveFibonacci rf = new RecursiveFibonacci();
        for (int i = 0; i <= 10; i++)
            System.out.println(rf.fibonacci(i));
    }
}

程序执行的结果是：

方法引用

Java 8提供的方法引用，其指向的是方法。方法引用的格式如下：

interface Callable {
    void call(String s); // 与hello()和show()的签名了保持一致
}

class Describe {
    void show(String msg) {
        System.out.println(msg);
    }
}

public class MethodReferences {
    static void hello(String name) {
        System.out.println("Hello, " + name);
    }

    static class Description { // 定义一个内部类
        String about;

        Description(String desc) {
            about = desc;
        }

        void help(String msg) {
            System.out.println(about + " " + msg);
        }
    }

    static class Helper {
        static void assist(String msg) { // assist()是静态内部类中的一个静态方法
            System.out.println(msg);
        }
    }

    public static void main(String[] args) {
        Describe d = new Describe();
        Callable c = d::show; // 将Describe对象的show方法赋给了Callable
        c.call("call()"); // 通过call()，调用了show()

        c = MethodReferences::hello; // 等号右边是一个静态方法引用
        c.call("Bob");

        c = new Description("valuable")::help; // 对某个活跃对象上的方法的方法引用（“绑定方法引用”）
        c.call("information");

        c = Helper::assist; // 获得静态内部类中的静态方法的方法引用
        c.call("Help!");
    }
}

程序执行的结果是：

在上述程序中，Callable.call()、Describe.show()和MethodReferences.hello()，这三者的签名保持了一致。这解释了为什么语句 Callable c = d::show; 及其之后的语句能够顺利编译。

Runnable

Runnable是一个java.lang包提供的接口。这个包遵循特殊的单方法接口格式：它的run()方法没有参数，也没有返回值。

因此，可以将lambda表达式或方法引用用作Runnable：

class Go {
    static void go() {
        System.out.println("方法引用Go::go()");
    }
}

public class RunnableMethodReference {
    public static void main(String[] args) {
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("定义一个run()方法");
            }
        }).start();

        new Thread(() -> System.out.println("这是一个lambda表达式")).start();

        new Thread(Go::go).start();
    }
}

程序执行的结果是：

Thread类在官方文档中的描述如下：

Thread会接受一个Runnable作为其构造器参数，它的start()方法会调用run()。

只有匿名内部类需要提供run()方法。

未绑定方法引用

未绑定方法引用：指的是尚未关联到某个对象的普通（非静态）方法。对于未绑定引用，必须先提供对象，然后才能使用：

class X {
    String f() {
        return "X::f()";
    }
}

interface MakeString {
    String make();
}

interface TransformX {
    String transform(X x);
}

public class UnboundMethodReference {
    public static void main(String[] args) {
//      MakeString ms = X::f; // 无效的方法引用
        TransformX sp = X::f;
        X x = new X();

        // 下列两条语句的效果是相同的
        System.out.println(sp.transform(x));
        System.out.println(x.f());
    }
}

程序执行的结果是：

在上述例子之前，示例中对方法的引用，方法与其关联接口的签名是相同的。但这里出现了特例：

MakeString ms = X::f;

编译器不允许上述语句的编译，若强制执行，会引发报错（此为IDEA的报错信息）：

这个报错指出X::f是一个未绑定方法引用，因为这里涉及到了一个隐藏的参数：this。若把这条有问题的语句换成下列语句，则没有问题：

X x = new X();
MakeString ms = x::f; // 无效的方法引用

上下两种语句的区别就在于，下方的语句提供了一个可供附着的X的对象x，这使得调动f()变为可能。X::f本身是无法“绑定到”一个对象上的。

显而易见，除了自己生成一个对象外，我们还有另一个方式能解决这个问题。关键在于，我们还需要一个额外的参数，如TransformX中所示：

String transform(X x);

这种做法告诉我们：函数式方法（接口中的单一方法）的签名与方法引用的签名不必完全匹配。

最后在看看这条语句：

System.out.println(sp.transform(x));

在前述知识的基础上，可以推断这条语句执行的过程：println()接受了一个未绑定引用，x作为参数在这个引用中调用了transform()，最终调用了x.f()。

若一个方法具有多个参数，则只需要让第一个参数使用这种this的模式即可：

class This {
    void two(int i, double d) {
    }

    void three(int i, double d, String s) {
    }

    void four(int i, double d, String s, char c) {
    }
}

interface TwoArgs {
    void call2(This athis, int i, double d);
}

interface ThreeArgs {
    void call3(This athis, int i, double d, String s);
}

interface FourArgs {
    void call4(This athis, int i, double d, String s, char c);
}

public class MultiUnbound {
    public static void main(String[] args) {
        TwoArgs twoargs = This::two;
        ThreeArgs threeargs = This::three;
        FourArgs fourargs = This::four;

        This athis = new This();
        twoargs.call2(athis, 11, 2.14);
        threeargs.call3(athis, 11, 3.14, "Three");
        fourargs.call4(athis, 11, 3.14, "Four", 'Z');
    }
}

构造器方法引用

同样的，也可以对构造器的引用进行捕获，此后通过这个引用来调用构造器：

class Dog {
    String name;
    int age = -1;

    Dog() {
        name = "流浪狗";
    }

    Dog(String nm) {
        name = nm;
    }

    Dog(String nm, int yrs) {
        name = nm;
        age = yrs;
    }
}

interface MakeNoArgs {
    Dog make();
}

interface Make1Arg {
    Dog make(String nm);
}

interface Make2Args {
    Dog make(String nm, int age);
}

public class CtorReference {
    public static void main(String[] args) {
        // 所有这3个构造器都只有一个名字 ::new
        MakeNoArgs mna = Dog::new;
        Make1Arg m1a = Dog::new;
        Make2Args m2a = Dog::new;

        Dog dn = mna.make();
        Dog d1 = m1a.make("卡卡");
        Dog d2 = m2a.make("拉尔夫", 4);
    }
}

注意语句Dog::new。3条相同的语句告诉我们，这些构造器都有（且只有）一个名字 —— ::new。并且每一个引用都被赋予了不同的接口，编译器可以从接口来推断所需使用的构造器。

在这里，调用函数式接口方法（make()）意味着调用构造器。

函数式接口

方法引用和lambda表达式都需要先赋值，然后才能进行使用。而这些赋值都需要类型信息，让编译器确保类型的正确性。尤其是lambda表达式。例如：

x -> x.toString()

toString()方法会返回String，但上述语句并没有表示x的类型。这时候就需要进行类型推断了。因此，编译器必须要能够通过某种方式推断出x的类型。

还有其他例子：

(x, y) -> x + y // 需要考虑String类型存在与否
System.out::println

为了解决这种类型推断的问题，Java 8引入了包含一组接口的java.util.function，这些接口是lambda表达式和方法引用的目标类型。其中的每个接口都只包含了一个抽象方法（非抽象方法可以有多个），被称为函数式方法。

使用了这种”函数式方法“模式的接口，可以通过@FunctionalInterface注解来强制执行：

@FunctionalInterface
interface Functional { // 使用了注解
    String goodbye(String arg);
}

interface FunctionNoAnn { // 没有使用注解
    String goodbye(String arg);
}

//@FunctionalInterface
//interface NoFunctional{ // 内置了两个方法，不符合函数式方法定义
//    String goodbye(String arg);
//    String hello(String arg);
//}

public class FunctionalAnnotation {
    public String goodbye(String arg) {
        return "Goodbye, " + arg;
    }

    public static void main(String[] args) {
        FunctionalAnnotation fa = new FunctionalAnnotation();
        Functional f = fa::goodbye;
        FunctionNoAnn fna = fa::goodbye;
//        Functional fac = fa; // 类型不兼容

        Functional f1 = arg -> "Goodbye, " + arg;
        FunctionNoAnn fnal = arg -> "Goodbye, " + arg;
    }
}

@FunctionalInterface注解是可选的。当只有一个方法时，Java把main()中的Functional和FunctionalNoAnn都视为了函数式接口。

现在看向两条赋值语句：

Functional f = fa::goodbye;
FunctionNoAnn fna = fa::goodbye;

这两条赋值语句均把一个方法（这个方法甚至不是接口方法的实现）赋值给了一个接口引用。这是Java 8增加的功能：若把一个方法引用或lambda表达式赋值给某个函数式接口（且类型匹配），匿名Java会调整这次赋值，使其能够匹配目标接口。

在底层的实现中，Java编译器会创建一个实现了目标接口的类的示例，并将我们进行赋值的方法引用或lambda表达式包裹在其中。

使用了@FunctionalInterface注解的接口也叫做单一抽象方法。

命名规则

java.util.function旨在创建一套足够完备的接口。一般来说，可以通过接口的名字了解接口的作用。以下是基本的命名规则（也可以去官方文档进行查看）：

只处理对象（而不是基本类型）：名字较为直接，如Function、Consumer和Predicate等。
接受一个基本类型的参数：使用名字的第一部分表示，如LongConsumer、DoubleFunction和InPredicate等（例外：基本的Supplier类型）。
返回的是基本类型的结果：用To表示，例如ToLongFunction<T>和IntToLongFunction。
返回类型和参数类型相同：被命名为Operator。UnaryOperator表示一个参数，BinaryOperator表示两个参数。
接受一个参数并返回boolean：被命名为Predicate。
接受两个不同类型的参数：名字中会有一个Bi（比如BiPredicate）。

因为基本类型的存在，Java在设计这些接口时不得不考虑众多的类型，这无疑增加了Java的复杂性。

例如：

import java.util.function.*;

class Foo {
}

class Bar {
    Foo f;

    Bar(Foo f) {
        this.f = f;
    }
}

class IBaz {
    int i;

    IBaz(int i) {
        this.i = i;
    }
}

class LBaz {
    long l;

    LBaz(long l) {
        this.l = l;
    }
}

class DBaz {
    double d;

    DBaz(double d) {
        this.d = d;
    }
}

public class FunctionVariants {
    static Function<Foo, Bar> f1 = f -> new Bar(f);
    static IntFunction<IBaz> f2 = i -> new IBaz(i);
    static LongFunction<LBaz> f3 = l -> new LBaz(l);
    static ToLongFunction<LBaz> f4 = lb -> lb.l;
    static DoubleToIntFunction f5 = d -> (int) d;

    public static void main(String[] args) {
        Bar b = f1.apply(new Foo());
        IBaz ib = f2.apply(11);

        LBaz lb = f3.apply(12);
        long l = f4.applyAsLong(lb);

        int i = f5.applyAsInt(14);
    }
}

在一些情况下，需要使用类型转换，否则编译器会报出截断错误。上述程序中的每个方法都会调用其关联的lambda表达式。

方法引用还有一些特别的用法：

import java.util.function.BiConsumer;

class In1 {
}

class In2 {
}

public class MethodConversion {
    static void accept(In1 i1, In2 i2) {
        System.out.println("accept()");
    }

    static void someOtherName(In1 i1, In2 i2) {
        System.out.println("somwOtherName()");
    }

    public static void main(String[] args) {
        BiConsumer<In1, In2> bic;

        bic = MethodConversion::accept;
        bic.accept(new In1(), new In2());

        bic = MethodConversion::someOtherName;
//      bic.someOtherName(new In1(), new In2); //行不通
        bic.accept(new In1(), new In2());
    }
}

程序执行的结果是：

以下是BitConSumer的文档说明：

这个接口有一个accept()方法可以被用作方法引用。并且，即使名字并不相同，如someOtherName()，只要参数类型和返回类型能够与BiConsumer的accept()相同，也没有问题。

使用函数式接口时，名字不重要，重要的是参数类型和返回类型。

Java会负责将我们起的名字映射到函数式方法上。若要调用我们的方法，就需要调用这个函数式方法的名字。

带有更多参数的函数式接口

java.util.function中的接口是有限的，同时也是直观易懂的。因此，当我们需要的接口并没有在java.util.function中被提供时，我们也可以轻松地编写自己的接口：

@FunctionalInterface
public interface TriFunction<T, U, V, R> {
    R apply(T t, U u, V v);
}

现在这个接口就可以被使用了：

public class TriFunctionTest {
    static int f(int i, long l, double d) {
        return 99;
    }

    public static void main(String[] args) {
        TriFunction<Integer, Long, Double, Integer> tf = TriFunctionTest::f;
        tf = (i, l, d) -> (i + l.intValue() + d.intValue());
        System.out.println(tf.apply(12, 12l, 12d));
    }
}

程序执行成功，输出36。

解决缺乏基本类型函数式接口的问题

可以通过使用BiConsumer这种面向对象的接口，开创建java.util.function中没有提供的，涉及int等基本类型的函数式接口：

import java.util.function.BiConsumer;

public class BiConsumerPermutations {
    static BiConsumer<Integer, Double> bicid = (i, d) -> System.out.format("%d, %f%n", i, d);
    static BiConsumer<Double, Integer> bicdi = (d, i) -> System.out.format("%f, %d%n", d, i);
    static BiConsumer<Integer, Long> bicil = (i, l) -> System.out.format("%d, %d%n", i, l);

    public static void main(String[] args) {
        bicid.accept(11, 45.14);
        bicdi.accept(11.45, 14);
        bicil.accept(1, 14L);
    }
}

程序执行的结果是：

上述程序使用了System.out.format()，这个方法支持%n这种跨平台的字符。

这个例子中发生了自动装箱和自动拆箱，通过这种方式，我们可以获得处理基本类型的接口。同样的，可以在其他函数式接口中使用包装类：

import java.util.function.Function;
import java.util.function.IntToDoubleFunction;

public class FunctionWithWrapped {
    public static void main(String[] args) {
        Function<Integer, Double> fid = i -> (double) i;
        IntToDoubleFunction fid2 = i -> i;
    }
}

需要注意的是使用强制类型转换的时机，否则会出现报错。

可以发现，只需要通过包装类就可以获得一个用来处理基本类型的函数式接口。因此，若存在函数式接口的基本类型变种，其唯一的原因就是防止自动装箱/拆箱过程带来的性能损耗。