java 8 lambdas深度研究

浏览数：25 / 时间：2015年06月08日

Java 8发布有一段日子，大家关注Java 8中的lambda可能更早，对Java 8中这一最重要的语言变化也基本熟悉了。这篇文章将深入研究Java 8中的lambda特性以及Stream接口等，讨论一些深层次的技术细节。
比如，一个lambda表达式序列化反序列化后，对捕获的上下文变量的引用的情况。 Lambda表达式递归。类方法的引用和实例方法的引用的区别。菱形继承的问题。 Stream接口的Lazy和eager模式。 Lambda的性能。

Java Lambda语法

尽管你已经很熟悉了，我们还是先回顾一下lambda表达式的语法。

“A lambda expression is like a method: it provides a list of formal parameters and a body—an expression or block—expressed in terms of those parameters,”
JSR 335

1	Function<Integer, Integer> fun = (Integer x, Integer y) -> {return x + y;}

如果body只有一个表达式，可以省略body的·大括号和 return。

1	Function<Integer, Integer> fun = (Integer x, Integer y) -> x + y

参数可以声明类型，也可以根据类型推断而省略。

1	Function<Integer, Integer> fun = (x, y) -> x + y

但是不能部分省略。

1	Function<Integer, Integer> fun = (x, Integer y) -> x + y //wrong

单个的参数可以省略括号。

1 2	Function<Integer, Integer> fun = (x) -> x+1 Function<Integer, Integer> fun = x -> x+1

但是不能加上类型声明。

1	Function<Integer, Integer> fun = Integer x -> x+1 //wrong

如果没有参数，括号是必须的。

1 2	() -> 1995 () -> { System.gc(); }

Java Lambda递归

匿名函数是没有名字的，但是Lambda表达式可以赋值给一个变量或者作为参数传递，这意味着它有”名字”。那么可以利用这个名字进行递归吗？
lambdafaq网站说可以。

1 2	Function<Long, Long> fib = x -> {if (x ==1 \|\| x == 2) return 1L; else return fib.apply(x -1) + x;}; System.out.println(fib.apply(3L));

实际你并不能编译这段代码，因为编译器认为fib可能没有初始化。

1	The local variable fib may not have been initialized

没办法递归了吗？
有一些hacked方法，如

1 2	IntToDoubleFunction[] foo = { null }; foo[0] = x -> { return ( x == 0)?1:x* foo[0].applyAsDouble(x-1);};

或者 (泛型数组的创建有些麻烦)

   @SuppressWarnings("unchecked")
private static <E> E[] newArray(Class clazz, int size)
{
    return (E[]) Array.newInstance(clazz, size);  
}
public static void main(String[] args) throws InstantiationException, IllegalAccessException, SecurityException, NoSuchMethodException {
	//Function<Long, Long> fib = x -> {if (x ==1 || x == 2) return 1L; else return fib.apply(x -1) + x;};
	
	Function<Long, Long>[] funs = newArray(Function.class, 1);
	funs[0] = x -> {if (x ==1 || x == 2) return 1L; else return funs[0].apply(x -1) + x;};
	System.out.println(funs[0].apply(10L));
}

或者使用一个helper类。

1 2	BiFunction<BiFunction, Long, Long> factHelper = (f, x) -> {if (x ==1 \|\| x == 2) return 1L; else return x + (long)f.apply(f,x-1);}; Function<Long, Long> fib = x -> factHelper.apply(factHelper, x);

捕获变量

就像本地类和匿名类一样， Lambda表达式可以捕获变量(capture variable)。

In addition, a local class has access to local variables. However, a local class can only access local variables that are declared final. When a local class accesses a local variable or parameter of the enclosing block, it captures that variable or parameter

但是Lambda表达式不强迫你将变量声明为final，只要它的行为和final 变量一样即可，也就是等价final.
下面的例子s不必声明为final，实际加上final也不会编译出错。

1
2
3

String s = "smallnest";
Runnable r = () -> System.out.println("hello " + s);
r.run();

但是下面的例子s实际已经不是final了，编译会出错。，

String s = "smallnest";
Runnable r = () -> System.out.println("hello " + s);
s = "colobu";
r.run();

下面的代码一样也会编译不成功：

1
2
3

String s = "smallnest";
Runnable r = () -> {s = "abc"; System.out.println("hello " + s);};
r.run();

注意final仅仅是变量不能再被赋值，而变量字段的值是可以改变的。

Sample s = new Sample();
s.setStr("smallnest");
Runnable r = () -> System.out.println("hello " + s.getStr());
s.setStr("colobu");
r.run();

这里我们可以更改s的str字段的值。

序列化

一般序列化/反序列化

Lambda表达式可以被序列化。下面是一个简单的例子。

Runnable r = (Runnable & Serializable)() -> System.out.println("hello serialization");
FileOutputStream fos = new FileOutputStream("Runnable.lambda");
ObjectOutputStream os = new ObjectOutputStream(fos);
os.writeObject(r);
FileInputStream fis = new FileInputStream("Runnable.lambda");
ObjectInputStream is = new ObjectInputStream(fis);
r = (Runnable) is.readObject();
r.run();

注意(Runnable & Serializable)是Java 8中新的语法。 cast an object to an intersection of types by adding multiple bounds.
一个Lambda能否序列化，要以它捕获的参数以及target type能否序列化为准。当然，不鼓励在实践中使用序列化。上面的例子r实现了Serializable接口，而且没有captured argument，所以可以序列化。

带捕获变量的序列化/序列化

再看一个带captured argument的例子。

	class Sample implements Serializable {
	private String str;
	public String getStr() {
		return str;
	}
	public void setStr(String str) {
		this.str = str;
	}
}
	public static void serializeLambda() throws Exception {
		Sample s = new Sample();
		s.setStr("smallnest");
		SampleSerializableInterface r = () -> System.out.println("hello " + s.getStr());
		FileOutputStream fos = new FileOutputStream("Runnable.lambda");
		ObjectOutputStream os = new ObjectOutputStream(fos);
		os.writeObject(r);
		s.setStr("colobu");
	}
	public static void deserializeLambda() throws Exception {
		FileInputStream fis = new FileInputStream("Runnable.lambda");
		ObjectInputStream is = new ObjectInputStream(fis);
		SampleSerializableInterface r = (SampleSerializableInterface) is.readObject();
		r.run();
	}

可以看到连同captured argument s一同序列化了。即使反序列化出来，captured argument也不是原来的s了。
结果输出hello smallnest。

方法引用

方法引用是一个有趣的特性，方法类似指针一样可以被直接引用。新的操作符”::”用来引用类或者实例的方法。

static method reference

BiFunction<Long,Long,Integer> bf = Long::compare;
Long a = 10L;
Long b = 11L;
System.out.println(bf.apply(a, b));

instance method reference

1 2	Consumer<String> c = System.out::println; c.accept("hello colobu");

以上两种情况引用的方法签名应和 target type的方法签名一样，方法的名字不一定相同。

arbitrary instance reference

1 2	String[] stringArray = { "Barbara", "James", "Mary", "John", "Patricia", "Robert", "Michael", "Linda" }; Arrays.sort(stringArray, String::compareToIgnoreCase);

这是一个很有趣的使用方法。可以引用任意的一个类型的实例。等价的lambda表达式的参数列表为(String a, String b)，方法引用会调用a.compareToIgnoreCase(b)。

constructor reference

另一种特殊的方法引用是对构造函数的引用。
对构造函数的引用类似对静态方法的引用，只不过方法名是new。一个类有多个构造函数，会根据target type选择最合适的构造函数。

多继承

由于Java 8引入了缺省方法(default method)的特性,Java也想其它语言如C++一样遇到了多继承的问题。这里列出两个典型的多继承的情况。

三角继承

三角继承如下图所示。
A
|\
| \
| B
| /
C

	class A {
	public A () {
		System.out.println("A()");
	}
	
	public A(int x) {
		System.out.println("A(int x)");
	}
}

1 2	C c = new C(); c.say(); //B says

菱形继承

菱形继承如下图所示
A
/\
/ \
B C
\ /
D

interface A {	 
	 default void say() {
		 System.out.println("A says");
	 }
}
interface B extends A{
	 
	 default void say() {
		 System.out.println("B says");
	 }
}
interface C extends A{
	 
	 default void say() {
		 System.out.println("C says");
	 }
}
class D implements A, B, C{
	 	 
}

直接编译出错。原因是Duplicate default methods.
你需要在D中重载say方法，自定义或者使用父类/接口的方法。注意其写法接口.super.default_method_name

	class D implements A, B, C{
	public void say() {
		 B.super.say();
	}	 
}

叉型继承

叉型继承如下图所示

B C
\ /
D

interface B {	 
	 default void say() {
		 System.out.println("B says");
	 }
}
class C {
	 
	 public void say() {
		 System.out.println("C says");
	 }
}
class D extends C implements  B{
	  
}

上面的代码输出C says。

原则：
基本上，你可以根据以下三条原则判断多继承的实现规则。

类优先于接口。如果一个子类继承的父类和接口有相同的方法实现。那么接口中的定义会被忽略。如第三个例子。
子类型中的方法优先于府类型中的方法。如第一个例子。
如果以上条件都不满足，如第二个例子，则必须显示覆盖/实现其方法，或者声明成abstract。

Stream接口的`lazy`方法和`eager`方法

新增加的Stream接口有很多方法。

lazy例子：

1	allStudents.stream().filter(s -> as.age> 16);

filter并不会马上对列表进行遍历筛选，它只是为stream加上一些”秘方”。当前它的方法实现不会被执行。直到遇到eager类型的方法它才会执行。

eager例子:

1	allStudents.stream().filter(s -> as.age> 16).count（）;

原则:
看方法的返回值。如果返回Stream对象，那么它是lazy的，如果返回其它类型或者void，那它是eager的，会立即执行。

Functional interface只能有一个方法吗?

Functional interface又被称作Single Abstract Method (SAM)或者Role Interface。
那么接口中只能声明一个方法吗？
上面的例子也表明，你可以在functional interface中定义多个default method。事实上java.util.function下好多functional interface都定义default method.
那么除去default method, functional interface可以声明多个的方法吗？看个例子

interface MyI {
	void apply(int i);
	
	String toString();
}

MyI声明了两个方法apply和toString()。它能作为一个lambda 表达式的target type吗？

1 2	MyI m = x -> System.out.println(x); m.apply(10);

没问题，代码可以正常编译，程序正常运行。
但是，等等，不是functional interface只能声明一个abstract的方法吗？
事实上你看第二个方法比较特殊，它和Object的方法签名相同。它是对象隐性实现的一个方法，所以可以忽略它。

同样，interface Foo { boolean equals(Object obj); }也不是一个functional interface，因为没有声明一个方法。
``` java
interface Foo {
int m();
Object clone();
}
也不是一个functional interface，因为Object.clone不是public类型的。

Lambda的性能

Oracle公司的性能工程师Sergey Kuksenko有一篇很好的性能比较的文档： JDK 8: Lambda Performance study，详细而全面的比较了lambda表达式和匿名函数之间的性能差别。这里是视频。 16页讲到最差（capture）也和inner class一样， non-capture好的情况是inner class的5倍。

lambda开发组也有一篇ppt，其中也讲到了lambda的性能(包括capture和非capture的情况)。看起来lambda最差的情况性能内部类一样，好的情况会更好。

郑重声明：本站内容如果来自互联网及其他传播媒体，其版权均属原媒体及文章作者所有。转载目的在于传递更多信息及用于网络分享，并不代表本站赞同其观点和对其真实性负责，也不构成任何其他建议。

java 8 lambdas深度研究