第十三章 函数式编程

函数式编程语言操纵代码片段就像操作数据一样容易。 虽然 Java 不是函数式语言，但 Java 8 Lambda 表达式和方法引用 (Method References) 允许你以函数式编程。

OO（object oriented，面向对象）是抽象数据，FP（functional programming，函数式编程）是抽象行为。

Lambda 表达式和方法引用并没有将 Java 转换成函数式语言，而是提供了对函数式编程的支持。这对 Java 来说是一个巨大的改进。因为这允许你编写更简洁明了，易于理解的代码。

没有泛型 Lambda，所以 Lambda 在 Java 中并非一等公民。

Lambda表达式

Lambda 表达式是使用最小可能语法编写的函数定义：

1. Lambda 表达式产生函数，而不是类。 在 JVM（Java Virtual Machine，Java 虚拟机）上，一切都是一个类，因此在幕后执行各种操作使 Lambda 看起来像函数 —— 但作为程序员，你可以高兴地假装它们“只是函数”。
2. Lambda 语法尽可能少，这正是为了使 Lambda 易于编写和使用。

任何 Lambda 表达式的基本语法是：

1. 参数。
2. 接着 ->，可视为“产出”。
3. -> 之后的内容都是方法体。

递归

递归函数是一个自我调用的函数。可以编写递归的 Lambda 表达式，但需要注意：递归方法必须是实例变量或静态变量，否则会出现编译时错误。

方法引用

Runnable接口

Runnable 接口自 1.0 版以来一直在 Java 中，因此不需要导入。它也符合特殊的单方法接口格式：它的方法 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() {public void run() {System.out.println("Anonymous");}}).start();new Thread(() -> System.out.println("lambda")).start();new Thread(Go::go).start();}
}

未绑定的方法引用

未绑定的方法引用是指没有关联对象的普通（非静态）方法。 使用未绑定的引用之前，我们必须先提供对象。

使用未绑定的引用时，函数方法的签名（接口中的单个方法）不再与方法引用的签名完全匹配。 理由是：你需要一个对象来调用方法。

class This {void two(int i, double d) {System.out.println("This two " + i + " , " + d);}void three(int i, double d, String s) {System.out.println("This three " + i + " , " + d + " , " + s);}void four(int i, double d, String s, char c) {System.out.println("This three " + i + " , " + d + " , " + s + " , " + 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, 3.14);threeargs.call3(athis, 11, 3.14, "Three");fourargs.call4(athis, 11, 3.14, "Four", 'Z');}
}

构造函数引用

class Dog {String name;int age = -1; // For "unknown"Dog() {name = "stray";}Dog(String nm) {name = nm;}Dog(String nm, int yrs) {name = nm;age = yrs;}@Overridepublic String toString() {return "Dog [name=" + name + ", age=" + age + "]";}}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) {MakeNoArgs mna = Dog::new; // [1]Make1Arg m1a = Dog::new; // [2]Make2Args m2a = Dog::new; // [3]Dog dn = mna.make();System.out.println(dn);Dog d1 = m1a.make("Comet");System.out.println(d1);Dog d2 = m2a.make("Ralph", 4);System.out.println(d2);}
}

函数式接口

方法引用和 Lambda 表达式必须被赋值，同时编译器需要识别类型信息以确保类型正确。

怎么知道传递给方法的参数的类型？
为了解决这个问题，Java 8 引入了 java.util.function 包。它包含一组接口，这些接口是 Lambda 表达式和方法引用的目标类型。 每个接口只包含一个抽象方法，称为函数式方法。

在编写接口时，可以使用 @FunctionalInterface 注解强制执行此“函数式方法”模式。

@FunctionalInterface 注解是可选的。接口中如果有多个方法则会产生编译时错误消息。

Java 8 允许我们以简便的语法为接口赋值函数。

java.util.function 包旨在创建一组完整的目标接口，使得我们一般情况下不需再定义自己的接口。这主要是因为基本类型会产生一小部分接口。 如果你了解命名模式，顾名思义就能知道特定接口的作用。
以下是基本命名准则：

1. 如果只处理对象而非基本类型，名称则为 Function，Consumer，Predicate 等。参数类型通过泛型添加。
2. 如果接收的参数是基本类型，则由名称的第一部分表示，如 LongConsumer，DoubleFunction，IntPredicate 等，但基本 Supplier 类型例外。
3. 如果返回值为基本类型，则用 To 表示，如 ToLongFunction <T> 和 IntToLongFunction。
4. 如果返回值类型与参数类型一致，则是一个运算符：单个参数使用 UnaryOperator，两个参数使用 BinaryOperator。
5. 如果接收两个参数且返回值为布尔值，则是一个谓词（Predicate）。
6. 如果接收的两个参数类型不同，则名称中有一个 Bi。

下表描述了 java.util.function 中的目标类型（包括例外情况）：

在使用函数接口时，名称无关紧要——只要参数类型和返回类型相同。 Java 会将你的方法映射到接口方法。 要调用方法，可以调用接口的函数式方法名，而不是你的方法名。

高阶函数

高阶函数（Higher-order Function）只是一个消费或产生函数的函数。

闭包

Java 8 提供了有限但合理的闭包支持。

从 Lambda 表达式引用的局部变量必须是 final 或者是等同 final 效果的。

等同 final 效果（Effectively Final）。这个术语是在 Java 8 才开始出现的，表示虽然没有明确地声明变量是 final 的，但是因变量值没被改变过而实际有了 final 同等的效果。 如果局部变量的初始值永远不会改变，那么它实际上就是 final 的。

应用于对象引用的 final 关键字仅表示不会重新赋值引用。 它并不代表你不能修改对象本身。

函数组合

一些 java.util.function 接口中包含支持函数组合的方法。

public class FunctionComposition {static Function<String, String> f1 = s -> {System.out.println(s);return s.replace('A', '_');}, f2 = s -> s.substring(3), f3 = s -> s.toLowerCase(), f4 = f1.compose(f2).andThen(f3);public static void main(String[] args) {System.out.println(f4.apply("GO AFTER ALL AMBULANCES"));}
}

public class PredicateComposition {static Predicate<String> p1 = s -> s.contains("bar"), p2 = s -> s.length() < 5, p3 = s -> s.contains("foo"),p4 = p1.negate().and(p2).or(p3);public static void main(String[] args) {Stream.of("bar", "foobar", "foobaz", "fongopuckey").filter(p4).forEach(System.out::println);}
}

柯里化和部分求值

柯里化意为：将一个多参数的函数，转换为一系列单参数函数。

对于每个级别的箭头级联（Arrow-cascading），在类型声明中包裹了另一个 Function。