java 复合方法_《Java 8 实战》Ch3: Lambda表达式（下）：类型与限制、方法引用、复合...

李文轩 2019-04-23

3.5 类型的检查和判断；变量捕获限制

类型检查

Lambda的类型是从使用Lambda的上下文推断出来的。

Lambda表达式需要的类型称为目标类型 。

Lambda表达式的类型检查的过程

//Main

List heavierThan150g = filter(inventory, (Apple a) -> a.getWeight() > 150);

//Lambda表达式的类型检查的过程

//1. 找到filter方法的声明 -> filter(List inventory, Predicate p)

//2. Lambda所在的第二个参数为 Predicate，T绑定了Apple

//3. Predicate 是一个函数式接口，包含了一个test的抽象方法

//4. test的函数描述符为 接受一个Apple对象，返回一个boolean值

//5. 查看Lambda的签名和(4)的描述符是否一致，

类型推断

在Java 8的Lambda表达式中，如果没有加入参数的显式类型，Java编译器可以从上下文推断出用什么函数式接口来配合Lambda表达式，即推断出Lambda表达式的签名。

//Lambda表达式的参数没有写出显式类型

List greenApples = filter(inventory, a -> "green".equals(a.getColor());

//写出了显式类型，编译器没有进行类型推断

Comparator c = (Apple a1, Apple a2) -> a1.getWeight().compareTo(a2.getWeight());

//没有写出显式类型，编译器将进行类型推断

Comparator c = (a1, a2) -> a1.getWeight().compareTo(a2.getWeight());

有时候写出显式类型会更便于阅读，有时候隐去显式类型代码看上去更加直接和简洁。

Lambda使用局部变量

Lambda表达式与匿名类一样，是允许使用自由变量的，即在外层作用域中定义的变量

//以下代码是有效的

int portNumber = 1337;

Runnable r = () -> System.out.println(portNumber);

对于实例变量和静态变量，Lambda表达式可以没有限制的使用

但是对域局部变量，局部变量必须显式声明为 final或者事实上是 final，即 Lambda表达式只能捕获指派给它们的局部变量一次。

//以下代码是无效的

int portNumber = 1337;

Runnable r = () -> System.out.println(portNumber);

portNumber = 31337;

对局部变量的限制的原因

实例变量和局部变量背后的实现的不同

实例变量都存储在堆中，局部变量都存储在栈上

如果Lambda是在一个线程中使用，使用此线程时，在分配该变量的线程将这个变量收回之后，去访问该变量。(这样可能会发生内存读取的错误)

Java在访问自由局部变量时，实际上是访问变量的副本，而不是访问原始变量。

因为是访问副本，所以需要用 final来限制变化，或者隐形的 final即只赋值一次。

3.6 方法引用

方法引用是根据已有的方法实现来创建Lambda表达式

用方法引用(显式地指明方法的名称)会让代码更具有可读性。

具体操作：目标引用放在 ::前，方法名称放在后面

一些Lambda表达式等效的方法引用

//Lambda

(Apple a) -> a.getWeight()

//方法引用

Apple::getWeight

//Lambda

() -> Thread.currentThread().dumpStack()

//方法引用

Thread.currentThread::dumpStack

//Lambda

(str, i) -> str.substring(i)

//方法引用

String::substring

//Lambda

(String s) -> System.out.println(s)

//方法引用

System.out.println

方法引用的三种类型

指向静态方法的方法引用

比如 Integer 的 parseInt 方法，可以写作 Integer::parseInt

//Lambda

(args) -> ClassName.staticMethod(args)

//方法引用

ClassName::staticMethod

指向任意类型实例方法的方法引用

比如 String 的 length 方法，可以写作 String::length

//Lambda

(arg0, rest) -> arg0.instanceMethod(rest)

//方法引用

ClassName::instanceMethod

指向现有对象的实例方法的方法引用

比如你有一个局部变量 greenApple 用于存放 Apple 类型的对象，它支持实例方法 getColor，那么可以写作 greenApple::getColor

//Lambda

(args) -> expr.instanceMethod(args)

//方法引用

expr::instanceMethod

** 第二和第三的区别在于，第二个类型的方法引用是传递一个实例，这个实例会作为Lambda的参数；第三个方法则是在Lambda表达式外的已存在的对象。

** 一开始会有一些懵，可能因为是在方法引用里看不到函数所用的参数。实际上，因为是用已定义的方法来代替Lambda表达式传递到其他方法中，不需要再在这里显式参数；编译器会在运行时，自动根据签名来检查。函数的参数传递则在调用函数式接口的方法时，比如说 Predicate 的 test，参数通过test传递。

构造函数引用

实际上和指向静态方法的引用类似，用类型的名称和 new关键字； Classname::new

//若构造函数没有参数，Supplier的签名就适用；() -> T

//这个引用指向默认的Apple构造函数

Supplier c1 = Apple::new

Apple a1 = c1.get();

//等价的Lambda表达式

Supplier c1 = () -> new Apple();

Apple a1 = c1.get();

//若构造函数有参数，Function的签名就适用；T -> R

//这个引用指向Apple(Integer weight)的构造函数

Function c2 = Apple::new;

Apple a2 = c2.apply(110);

//等价的Lambda表达式

Function c2 = (weight) -> new Apple(weight);

Apple a2 = c2.apply(110);

3.8 复合Lambda表达式

谓词复合

Predicate 接口包括三个方法： negate、and和or，都返回一个Predicate的实例；这些方法能让已有的Predicate创建更加复杂的谓词。

需要注意的是and和or方法是按照表达式链中的位置，从左向右确定优先级

a.or(b).and(c)等价于 (a || b) && c

//用negate返回一个Predicate的非，比如苹果不是红的

Predicate notRedApple = redApple.negate();

//用and串联两个方法，用来得到又红又大的苹果

Predicate redAndHeavyApple = redApple.and( a -> a.getWeight() > 150);

//用or串联多个方法，等到结果要么是又红又大的苹果要么是绿苹果

Predicate redAndHeavyApple =

redApple.and( a -> a.getWeight() > 150)

.or(a -> "green".equals(a.getColor()));

函数复合

Function 接口包括两个方法：andThen和compose，都返回一个Function的实例。

andThen方法会先把输入应用到一个给定函数，再将这个输出应用到另一个函数。

Function f = x -> x + 1;

Function g = x -> x * 2;

Function h = f.andThen(g); //数学上写作 g(f(x))

int result = h.apply(1);

//结果为4

compose方法会先把给定函数用作compose的参数里给的那个函数，然后在把函数本身用于结果。

Function f = x -> x + 1;

Function g = x -> x * 2;

Function h = f.compose(g); //数学上写作 f(g(x))

int result = h.apply(1);

//结果为3

compose方法可以用于一些流水线中

public class Letter{

public static String addHeader(String text){

return "From xxx : " + text;

}

public static String add addFooter(String text){

return text + " Kind regards";

}

public static String checkSpelling(String text){

return text.replaceAll("labda", "lambda");

}

}

//Main

//创建一个流水线，给信加上抬头，检查拼写，再加上落款

Function addHeader = Letter::addHeader;

Function transformationPipeline

= addHeader.andThen(Letter::checkSpelling).andThen(Letter::addFooter);

Reference:

[1] Fusco, Mario, and Alan Mycroft. Java 8 in Action: Lambdas, Streams, and Functional-Style Programming. Manning, 2015.