Java JDK1.8新特性
2014-06-12 17:26
423 查看
一、lambda含义
lambda表示数学符号“λ”，计算机领域中λ代表“λ演算”，表达了计算机中最基本的概念：“调用”和“置换”。在很多动态语言和C#中都有相应的lambda语法，这类语法都为了简化代码，提高运行效率。
二、lambda 项目的背景，参考这里。
无论是面向对象语言还是函数式语言，基本数值都可以被动态的封装入程序动作：面向对象语言通过“方法”，函数式语言通过“函数。
介于“方法”和“函数”的定义有很多种，补充下IBM知识库的解释：
在面向对象语言中，方法不是一阶值（First-class value），在函数式语言中，函数是一阶值。在函数式语言中，函数可以作为另一个函数的返回值或参数，还可以作为一个变量的值，函数可以嵌套定义，而在面向对象语言中的的“方法”做不到这点。
Java可以说是面向对象语言的代表，如果要调用其方法，需要先创建对象。不过Java对象都是“重量级”的，实例化具体的类的对象，需要经过定义和申明两个阶段。比如定义方法，并给内部字段赋初始值。但是一个对象只包含一个方法的情况很多，比如实现API中的“回调接口”功能的类，在swing中有接口：
Java代码
<span><span><span style="">public interface ActionListener {
void actionPerformed(ActionEvent e);
}</span></span></span>
现有的实现方式大多是：
Java代码
<span><span><span style="">button.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
ui.dazzle(e.getModifiers());
}
});</span></span></span>
很多现有的类库都基于这种设计实现，所以对于代码被明确定义运行在单独线程的API来说，匿名内部类尤为重要。这些匿名内部类只存在于创建它的线程中。但是在并行计算领域，CPU的制造商着力发展多核技术来提升CPU的功能，这么做几乎无法依靠多核的优势来提升其性能。
鉴于回调函数和其他功能式语法的关系越来越密切，所以必须建立尽可能的轻量级的数据模型（从编码角度而言，性能方面下文再说）。对于这点来说匿名内部类的缺点如下：
1. 语法相对复杂。
2. 在调用内部类的上下文中，指引和this的指代容易混淆。
3. 类加载和实例创建语法不可避免。
4. 不能引用外部的非final对象。
5. 不能抽象化控制流程
针对这些问题，lambda项目致力于
1. 消除问题1和问题2，通过引入更简单的表达式和局部变量的定义规则。
2. 回避问题3，定义更灵活更友善的语法。这里只是回避，类加载和实例化本身不可避免。下文会解释。
3. 改善问题4，允许用户使用最终有效的局部变量。
不过lambda项目目前并不能解决所有关于内部类的问题。问题4和问题5没有完全解决，这计划在将类版本中继续改善。对于性能方面，原文也没有提，不过后面有些补充。
三、lambda用法
通过上文可以了解到，lambda语法是针对“回调接口”和“匿名内部类”作出的改进，所以lambda的语法目前仅对于部分接口，这些接口的特点是只含一个抽象方法，在lambda项目中，早期称为SAM类型(SAM = single abstract method 即单一抽象方法)。在最新的文档中(即这个版本)，它们有了新名字，叫函数接口（functional interface)，比如：
1 java.lang.Runnable
2 java.util.concurrent.Callable
3 java.security.PrivilegedAction
4 java.util.Comparator
5 java.io.FileFilter
6 java.nio.file.PathMatcher
7 java.lang.reflect.InvocationHandler
8 java.beans.PropertyChangeListener
9 java.awt.event.ActionListener
10 javax.swing.event.ChangeListener
lambda的语法包括三部分
1、参数列表
2、箭头符号"->"
3、代码块。
其中代码块很像一个方法体，return语句将控制权交还给匿名方法(anonymous method，即lambda表达式)的调用者；break和continue不能出现在函数体的顶部，不过可以出现在内部的循环里；如果代码块得出最终结果，那么每一个控制路径(control path) 必须都有返回或抛出异常。
如果代码块只有简单一行，可以省略return关键字和“{}”符号(以下所写的例子都是基于JDK 1.8 lambda预览版)，比如：
Java代码
<span><span><span style="">public class LambdaTest {
public static void main(String... args) {
//这里有{}和return 以及 ;
Runnable r = () -> { System.out.println("hello world"); };
//这里不需要{}和return
java.util.Comparator<String> c = (String s1, String s2) -> s2.length()-s1.length();
r.run();
System.out.println(c.compare("s1", "12323"));
}
}</span></span></span>
输出为：
hello world
3
除了这些现有接口，我们还可以自定义函数接口：
Java代码
<span><span><span style="">public class LambdaTest {
interface lambdaInterface {
public void me(String str);
}
public static void main(String... args) {
lambdaInterface li = (String s)->{System.out.println(s);};
li.me("hello world!");
}
}</span></span></span>
输出为：
hello world!
新的lambda方法从语法上的确是简化了很多。和lambda第一次发布的语法相比也优雅很多。
四、lambda代码块的字节码
看完了语法的确很简单，那么lambda是怎么实现的，就得从字节码考察了。这里和匿名内部类做个对比，编译如下代码：
Java代码
<span><span><span style="">public class LambdaTest {
lambdaInterface li1 = ()->{System.out.println(this);};
lambdaInterface li2 = new lambdaInterface(){
public void me(){
System.out.println(this);
}
};
public static void main(String... args) {
LambdaTest lt = new LambdaTest();
lt.li1.me();
lt.li2.me();
}
}
interface lambdaInterface {
public void me();
}</span></span></span>
编译后有会有四个文件：
LambdaTest.class
LambdaTest$1.class
LambdaTest$2.class
lambdaInterface.class
它的的输出结果为：
LambdaTest@200bde
LambdaTest$1@1eb41d6
结果很明显地显示，lambda代码块和内部类的this的指引是不一样的。lambda代码块输出的是调用者的this，即lambdaTest.class的实例。匿名内部类输出的是自己lambdaTest$1.class的实例。
先看看lambdaTest.class的字节码：
Txt代码
<span><span><span style="">public class LambdaTest {
lambdaInterface li1;
lambdaInterface li2;
public LambdaTest();
Code:
0: aload_0
1: invokespecial #1 // Method java/lang/Object."<init>":()V
4: aload_0
5: new #2 // class LambdaTest$2
8: dup
9: aload_0
10: aload_0
11: invokespecial #3 // Method LambdaTest$2."<init>":(LLambdaTest;LLambdaTest;)V
14: putfield #4 // Field li1:LlambdaInterface;
17: aload_0
18: new #5 // class LambdaTest$1
21: dup
22: aload_0
23: invokespecial #6 // Method LambdaTest$1."<init>":(LLambdaTest;)V
26: putfield #7 // Field li2:LlambdaInterface;
29: return
public static void main(java.lang.String...);
Code:
0: new #8 // class LambdaTest
3: dup
4: invokespecial #9 // Method "<init>":()V
7: astore_1
8: aload_1
9: getfield #4 // Field li1:LlambdaInterface;
12: invokeinterface #10, 1 // InterfaceMethod lambdaInterface.me:()V
17: aload_1
18: getfield #7 // Field li2:LlambdaInterface;
21: invokeinterface #10, 1 // InterfaceMethod lambdaInterface.me:()V
26: return
}</span></span></span>
从这里可以看出，lambda代码块和匿名内部类的调用方法是一样的，都是先创建一个方法，然后创建其句柄，这两个句柄分别对应lambdaTest$2.class和lambdaTest$1.class。
其中匿名内部类对应LambdaTest$1，它的字节码为：
Txt代码
<span><span><span style="">class LambdaTest$1 implements lambdaInterface {
final LambdaTest this$0;
LambdaTest$1(LambdaTest);
Code:
0: aload_0
1: aload_1
2: putfield #1 // Field this$0:LLambdaTest;
5: aload_0
6: invokespecial #2 // Method java/lang/Object."<init>":()V
9: return
public void me();
Code:
0: getstatic #3 // Field java/lang/System.out:Ljava/io/PrintStream;
3: aload_0
4: invokevirtual #4 // Method java/io/PrintStream.println:(Ljava/lang/Object;)V
7: return
}</span></span></span>
lambda代码块对应LambdaTest$2，它的字节码为：
Txt代码
<span><span><span style="">class LambdaTest$2 implements lambdaInterface {
LambdaTest encl$0;
final LambdaTest this$0;
LambdaTest$2(LambdaTest, LambdaTest);
Code:
0: aload_0
1: aload_1
2: putfield #1 // Field this$0:LLambdaTest;
5: aload_0
6: invokespecial #2 // Method java/lang/Object."<init>":()V
9: aload_0
10: aload_2
11: putfield #3 // Field encl$0:LLambdaTest;
14: return
public void me();
Code:
0: getstatic #4 // Field java/lang/System.out:Ljava/io/PrintStream;
3: aload_0
4: getfield #3 // Field encl$0:LLambdaTest;
7: invokevirtual #5 // Method java/io/PrintStream.println:(Ljava/lang/Object;)V
10: return
}
</span></span></span>
从它们的字节码可以很明显的看出，lambda代码块的字节码在初始化时多了putfield指令，在me()运行时，有getfield指令。从解释Field encl$0:LLambdaTest;中可以知道这步骤就是LambdaTest实例引用的入栈和出栈，所以lambda的代码块的this的引用是其调用者LambdaTest.class，这里和匿名内部类不一样。相比较而言，lambda代码块对this的引用更精准。
至此lambda项目的前两个目标已经完成。即简化语法，和明确对象指引。
五、lamdab的性能
在JDK1.7中，引入了虚拟机新指令，invokedynamic（有点函数指针的味道），将用于支持lambda项目，具体可以参考Rémi
Forax 的博客。
但是目前javap指令还不能直生成带有invokedynamic指令的字节码，不过可以通过别的工具来实现，可以参考周志明的文章。这里引用引用周志明的说明，简单的解释如下（详细的请看他的文章）：
每一处含有invokedynamic指令的位置都被称作“动态调用点（Dynamic Call Site）”，这条指令的第一个参数不再是代表方法符号引用的CONSTANT_Methodref_info常量，而是变为JDK 7新加入的CONSTANT_InvokeDynamic_info常量，从这个新常量中可以得到3项信息：引导方法（Bootstrap Method，此方法存放在新增的BootstrapMethods属性中）、方法类型（MethodType）和名称。引导方法是有固定的参数，并且返回值是java.lang.invoke.CallSite对象，这个代表真正要执行的目标方法调用。根据CONSTANT_InvokeDynamic_info常量中提供的信息，虚拟机可以找到并且执行引导方法，从而获得一个CallSite对象，最终调用要执行的目标方法上。
换句话说就是在虚拟机内部加入了类似C的函数指针功能。从以上的例子中可以看出，目前lambda的代码块是按照匿名内部类的方式进行工作的，即：内部类+方法句柄，那么虚拟机工作的第一步是加载内部类，再调用对应方法，如果使用过于平频繁，那么内部类的new动作开销就比较大了。在invokedynamic指令的帮助下，可以直接调用lambda所对应的方法，而不用创建内部类，这样就避免了“内部类”所带来的加载等问题。目前从lambda的话题库来看是这么解释invokedynamic如何工作和优势的。
在lamdba项目的说明中已经明确表示，在预览版中将lamdba代码块编译成内部类的形式是暂时的。最终将采用invokedynamic指令来实现，即提升性能的部分最终是invokedynamic指令对函数接口的支持行能力来提升。
不过手痒，还是自己测了下速度，仅供参考：
Java代码
<span><span><span style="">public class LambdaTest {
lambdaInterface li1 = (String s)->{System.out.println(s);};
lambdaInterface li2 = new lambdaInterface(){
public void me(String s){
System.out.println(s);
}
};
public static void main(String... args) {
//这里原来有错误，已经纠正了。
LambdaTest lt = new LambdaTest();
long l1 = System.currentTimeMillis();
for (int i = 0; i < 1000; i++) {
lt.li1.me("21");
}
long l2 = System.currentTimeMillis();
for (int i = 0; i < 1000; i++) {
lt.li2.me("21");
}
long l3 = System.currentTimeMillis();
System.out.println(l2-l1);
System.out.println(l3-l2);
}
}</span></span></span>
运行参数设置-server，其余默认，运行结果为
200
172
这么看来似乎lambda语法编译编译的代码块略慢一些。不过考虑的到是预览版，lamdab或者说invokedynamic指令的实际性能估计得等到JDK1.8正式发布才能一窥究竟。
仅管性能方面还没进步，不过灵活的语法已经带来了很多便利，对于脚本语言来说更方便。另外在闭包的意义上来说也更加完美。总的来说Lamdba还是很值得期待的。
注：本文转载自：http://blog.csdn.net/u010827436/article/details/9333181
lambda表示数学符号“λ”，计算机领域中λ代表“λ演算”，表达了计算机中最基本的概念：“调用”和“置换”。在很多动态语言和C#中都有相应的lambda语法，这类语法都为了简化代码，提高运行效率。
二、lambda 项目的背景，参考这里。
无论是面向对象语言还是函数式语言，基本数值都可以被动态的封装入程序动作：面向对象语言通过“方法”，函数式语言通过“函数。
介于“方法”和“函数”的定义有很多种，补充下IBM知识库的解释：
在面向对象语言中，方法不是一阶值（First-class value），在函数式语言中，函数是一阶值。在函数式语言中，函数可以作为另一个函数的返回值或参数，还可以作为一个变量的值，函数可以嵌套定义，而在面向对象语言中的的“方法”做不到这点。
Java可以说是面向对象语言的代表，如果要调用其方法，需要先创建对象。不过Java对象都是“重量级”的，实例化具体的类的对象，需要经过定义和申明两个阶段。比如定义方法，并给内部字段赋初始值。但是一个对象只包含一个方法的情况很多，比如实现API中的“回调接口”功能的类，在swing中有接口：
Java代码
<span><span><span style="">public interface ActionListener {
void actionPerformed(ActionEvent e);
}</span></span></span>
现有的实现方式大多是：
Java代码
<span><span><span style="">button.addActionListener(new ActionListener() {
public void actionPerformed(ActionEvent e) {
ui.dazzle(e.getModifiers());
}
});</span></span></span>
很多现有的类库都基于这种设计实现，所以对于代码被明确定义运行在单独线程的API来说，匿名内部类尤为重要。这些匿名内部类只存在于创建它的线程中。但是在并行计算领域，CPU的制造商着力发展多核技术来提升CPU的功能，这么做几乎无法依靠多核的优势来提升其性能。
鉴于回调函数和其他功能式语法的关系越来越密切，所以必须建立尽可能的轻量级的数据模型（从编码角度而言，性能方面下文再说）。对于这点来说匿名内部类的缺点如下：
1. 语法相对复杂。
2. 在调用内部类的上下文中，指引和this的指代容易混淆。
3. 类加载和实例创建语法不可避免。
4. 不能引用外部的非final对象。
5. 不能抽象化控制流程
针对这些问题，lambda项目致力于
1. 消除问题1和问题2，通过引入更简单的表达式和局部变量的定义规则。
2. 回避问题3，定义更灵活更友善的语法。这里只是回避，类加载和实例化本身不可避免。下文会解释。
3. 改善问题4，允许用户使用最终有效的局部变量。
不过lambda项目目前并不能解决所有关于内部类的问题。问题4和问题5没有完全解决，这计划在将类版本中继续改善。对于性能方面，原文也没有提，不过后面有些补充。
三、lambda用法
通过上文可以了解到，lambda语法是针对“回调接口”和“匿名内部类”作出的改进，所以lambda的语法目前仅对于部分接口，这些接口的特点是只含一个抽象方法，在lambda项目中，早期称为SAM类型(SAM = single abstract method 即单一抽象方法)。在最新的文档中(即这个版本)，它们有了新名字，叫函数接口（functional interface)，比如：
1 java.lang.Runnable
2 java.util.concurrent.Callable
3 java.security.PrivilegedAction
4 java.util.Comparator
5 java.io.FileFilter
6 java.nio.file.PathMatcher
7 java.lang.reflect.InvocationHandler
8 java.beans.PropertyChangeListener
9 java.awt.event.ActionListener
10 javax.swing.event.ChangeListener
lambda的语法包括三部分
1、参数列表
2、箭头符号"->"
3、代码块。
其中代码块很像一个方法体，return语句将控制权交还给匿名方法(anonymous method，即lambda表达式)的调用者；break和continue不能出现在函数体的顶部，不过可以出现在内部的循环里；如果代码块得出最终结果，那么每一个控制路径(control path) 必须都有返回或抛出异常。
如果代码块只有简单一行，可以省略return关键字和“{}”符号(以下所写的例子都是基于JDK 1.8 lambda预览版)，比如：
Java代码
<span><span><span style="">public class LambdaTest {
public static void main(String... args) {
//这里有{}和return 以及 ;
Runnable r = () -> { System.out.println("hello world"); };
//这里不需要{}和return
java.util.Comparator<String> c = (String s1, String s2) -> s2.length()-s1.length();
r.run();
System.out.println(c.compare("s1", "12323"));
}
}</span></span></span>
输出为：
hello world
3
除了这些现有接口，我们还可以自定义函数接口：
Java代码
<span><span><span style="">public class LambdaTest {
interface lambdaInterface {
public void me(String str);
}
public static void main(String... args) {
lambdaInterface li = (String s)->{System.out.println(s);};
li.me("hello world!");
}
}</span></span></span>
输出为：
hello world!
新的lambda方法从语法上的确是简化了很多。和lambda第一次发布的语法相比也优雅很多。
四、lambda代码块的字节码
看完了语法的确很简单，那么lambda是怎么实现的，就得从字节码考察了。这里和匿名内部类做个对比，编译如下代码：
Java代码
<span><span><span style="">public class LambdaTest {
lambdaInterface li1 = ()->{System.out.println(this);};
lambdaInterface li2 = new lambdaInterface(){
public void me(){
System.out.println(this);
}
};
public static void main(String... args) {
LambdaTest lt = new LambdaTest();
lt.li1.me();
lt.li2.me();
}
}
interface lambdaInterface {
public void me();
}</span></span></span>
编译后有会有四个文件：
LambdaTest.class
LambdaTest$1.class
LambdaTest$2.class
lambdaInterface.class
它的的输出结果为：
LambdaTest@200bde
LambdaTest$1@1eb41d6
结果很明显地显示，lambda代码块和内部类的this的指引是不一样的。lambda代码块输出的是调用者的this，即lambdaTest.class的实例。匿名内部类输出的是自己lambdaTest$1.class的实例。
先看看lambdaTest.class的字节码：
Txt代码
<span><span><span style="">public class LambdaTest {
lambdaInterface li1;
lambdaInterface li2;
public LambdaTest();
Code:
0: aload_0
1: invokespecial #1 // Method java/lang/Object."<init>":()V
4: aload_0
5: new #2 // class LambdaTest$2
8: dup
9: aload_0
10: aload_0
11: invokespecial #3 // Method LambdaTest$2."<init>":(LLambdaTest;LLambdaTest;)V
14: putfield #4 // Field li1:LlambdaInterface;
17: aload_0
18: new #5 // class LambdaTest$1
21: dup
22: aload_0
23: invokespecial #6 // Method LambdaTest$1."<init>":(LLambdaTest;)V
26: putfield #7 // Field li2:LlambdaInterface;
29: return
public static void main(java.lang.String...);
Code:
0: new #8 // class LambdaTest
3: dup
4: invokespecial #9 // Method "<init>":()V
7: astore_1
8: aload_1
9: getfield #4 // Field li1:LlambdaInterface;
12: invokeinterface #10, 1 // InterfaceMethod lambdaInterface.me:()V
17: aload_1
18: getfield #7 // Field li2:LlambdaInterface;
21: invokeinterface #10, 1 // InterfaceMethod lambdaInterface.me:()V
26: return
}</span></span></span>
从这里可以看出，lambda代码块和匿名内部类的调用方法是一样的，都是先创建一个方法，然后创建其句柄，这两个句柄分别对应lambdaTest$2.class和lambdaTest$1.class。
其中匿名内部类对应LambdaTest$1，它的字节码为：
Txt代码
<span><span><span style="">class LambdaTest$1 implements lambdaInterface {
final LambdaTest this$0;
LambdaTest$1(LambdaTest);
Code:
0: aload_0
1: aload_1
2: putfield #1 // Field this$0:LLambdaTest;
5: aload_0
6: invokespecial #2 // Method java/lang/Object."<init>":()V
9: return
public void me();
Code:
0: getstatic #3 // Field java/lang/System.out:Ljava/io/PrintStream;
3: aload_0
4: invokevirtual #4 // Method java/io/PrintStream.println:(Ljava/lang/Object;)V
7: return
}</span></span></span>
lambda代码块对应LambdaTest$2，它的字节码为：
Txt代码
<span><span><span style="">class LambdaTest$2 implements lambdaInterface {
LambdaTest encl$0;
final LambdaTest this$0;
LambdaTest$2(LambdaTest, LambdaTest);
Code:
0: aload_0
1: aload_1
2: putfield #1 // Field this$0:LLambdaTest;
5: aload_0
6: invokespecial #2 // Method java/lang/Object."<init>":()V
9: aload_0
10: aload_2
11: putfield #3 // Field encl$0:LLambdaTest;
14: return
public void me();
Code:
0: getstatic #4 // Field java/lang/System.out:Ljava/io/PrintStream;
3: aload_0
4: getfield #3 // Field encl$0:LLambdaTest;
7: invokevirtual #5 // Method java/io/PrintStream.println:(Ljava/lang/Object;)V
10: return
}
</span></span></span>
从它们的字节码可以很明显的看出，lambda代码块的字节码在初始化时多了putfield指令，在me()运行时，有getfield指令。从解释Field encl$0:LLambdaTest;中可以知道这步骤就是LambdaTest实例引用的入栈和出栈，所以lambda的代码块的this的引用是其调用者LambdaTest.class，这里和匿名内部类不一样。相比较而言，lambda代码块对this的引用更精准。
至此lambda项目的前两个目标已经完成。即简化语法，和明确对象指引。
五、lamdab的性能
在JDK1.7中，引入了虚拟机新指令，invokedynamic（有点函数指针的味道），将用于支持lambda项目，具体可以参考Rémi
Forax 的博客。
但是目前javap指令还不能直生成带有invokedynamic指令的字节码，不过可以通过别的工具来实现，可以参考周志明的文章。这里引用引用周志明的说明，简单的解释如下（详细的请看他的文章）：
每一处含有invokedynamic指令的位置都被称作“动态调用点（Dynamic Call Site）”，这条指令的第一个参数不再是代表方法符号引用的CONSTANT_Methodref_info常量，而是变为JDK 7新加入的CONSTANT_InvokeDynamic_info常量，从这个新常量中可以得到3项信息：引导方法（Bootstrap Method，此方法存放在新增的BootstrapMethods属性中）、方法类型（MethodType）和名称。引导方法是有固定的参数，并且返回值是java.lang.invoke.CallSite对象，这个代表真正要执行的目标方法调用。根据CONSTANT_InvokeDynamic_info常量中提供的信息，虚拟机可以找到并且执行引导方法，从而获得一个CallSite对象，最终调用要执行的目标方法上。
换句话说就是在虚拟机内部加入了类似C的函数指针功能。从以上的例子中可以看出，目前lambda的代码块是按照匿名内部类的方式进行工作的，即：内部类+方法句柄，那么虚拟机工作的第一步是加载内部类，再调用对应方法，如果使用过于平频繁，那么内部类的new动作开销就比较大了。在invokedynamic指令的帮助下，可以直接调用lambda所对应的方法，而不用创建内部类，这样就避免了“内部类”所带来的加载等问题。目前从lambda的话题库来看是这么解释invokedynamic如何工作和优势的。
在lamdba项目的说明中已经明确表示，在预览版中将lamdba代码块编译成内部类的形式是暂时的。最终将采用invokedynamic指令来实现，即提升性能的部分最终是invokedynamic指令对函数接口的支持行能力来提升。
不过手痒，还是自己测了下速度，仅供参考：
Java代码
<span><span><span style="">public class LambdaTest {
lambdaInterface li1 = (String s)->{System.out.println(s);};
lambdaInterface li2 = new lambdaInterface(){
public void me(String s){
System.out.println(s);
}
};
public static void main(String... args) {
//这里原来有错误，已经纠正了。
LambdaTest lt = new LambdaTest();
long l1 = System.currentTimeMillis();
for (int i = 0; i < 1000; i++) {
lt.li1.me("21");
}
long l2 = System.currentTimeMillis();
for (int i = 0; i < 1000; i++) {
lt.li2.me("21");
}
long l3 = System.currentTimeMillis();
System.out.println(l2-l1);
System.out.println(l3-l2);
}
}</span></span></span>
运行参数设置-server，其余默认，运行结果为
200
172
这么看来似乎lambda语法编译编译的代码块略慢一些。不过考虑的到是预览版，lamdab或者说invokedynamic指令的实际性能估计得等到JDK1.8正式发布才能一窥究竟。
仅管性能方面还没进步，不过灵活的语法已经带来了很多便利，对于脚本语言来说更方便。另外在闭包的意义上来说也更加完美。总的来说Lamdba还是很值得期待的。
注：本文转载自：http://blog.csdn.net/u010827436/article/details/9333181
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- java jdk1.7-1.8新特性
- [Java]_[JDK1.8新特性]
- Java JDK1.8新特性
- JDK1.8新特性(java)
- Java JDK1.8新特性
- Java--JDK1.8十大特性
- JAVA基础【1.5】《Java核心技术1》Java程序设计概述-Java JDK1.8新特性【收集】
- Java JDK1.8新特性
- java jdk 1.8 新增特性->（ lambda特性）
- Java还要再学一遍基础（四）JDK1.8新特性default，static
- 杰神之Java接口JDK1.8新特性
- java 基础 JDK各个版本的新特性1.5---1.8
- Java基础--JDK1.8新特性-Lamda
- Java JDK1.8新特性Lambda 表达式
- Java JDK1.8新特性
- JAVA 8 新特性详解-------与------- JDK 1.8 预览版 Lambda语法分析
- java jdk多线程新特性2
- 黑马程序员_java jdk5.0新特性和枚举的学习笔记
- java中的<?><T><E>详解Jdk5.0新特性Generic Types (泛型)
- Java学习笔记——JDK1.7的新特性。