在Java中传递一个代码段并不容易，不能直接传递代码段。Java是一个面向对象语言，所以必须构造一个对象，这个对象的类需要一个方法能包含所需的代码。lambda的出现有效的解决这个问题，让代码变得更加简洁。
示例：
class LengthComparator implements Comparator<String>{
public int compare(String first,String second){
return first.length() - second.length();
}
}
...
Arrays.sort(Strings,new LengthComparator());
Arrays.sort(strings,
(String first,String second)-> first.length() - second.length());
lambda表达式,也可称为闭包,是一个可传递的代码块，可以执行一次或多次。
一、lambda表达式的语法：
lambda表达式的语法：参数，箭头（->）以及一个表达式。
（String first,String second）
-> first.length() - second.length();
如无法放在一个表达式中，可放在{}中：
（String first,String second）->
{
if(first.length() < second.length()) return -1;
else if(first.length() > second.length()) return 1;
else return 0;
}
即使lambda表达式没有参数，仍然要提供空括号，就像无参数方法一样：
（）-> {for(int i = 100; i >= 0 ; i--) System.out.println(i) ; }
如果方法只有一个参数，而且这个参数的类型可以推导得出，那么甚至可以省略小括号：
ActionListener listener = event ->
System.out.println("The times is" + new Date());
//Instead of (event) -> ... or (ActionEvent event) -> ...
无需指定lambda表达式的返回值类型，lambda表达式的返回值类型总是会由上下文推导得出，例如：
（String first,String second）-> first.length() - second.length();
可以在需要int类型结果的上下文中使用。
示例：
package lambda; import javax.swing.*;
import java.util.Arrays;
import java.util.Date; /**
* Created by kong on 20/11/2017.
*/ public class LambdaTest {
public static void main(String[] args) {
String[] planets = new String[]{"Mercury","Venus","Mars",
"Jupiter","Saturn","Uranus","Neptune"};
System.out.println (Arrays.toString (planets));
System.out.println ("Sorted in dictionary order:");
Arrays.sort (planets);
System.out.println (Arrays.toString (planets));
System.out.println ("Sorted by length:");
Arrays.sort (planets,(first,second) -> first.length () - second.length ());
System.out.println (Arrays.toString (planets)); Timer t = new Timer (1000, event ->
System.out.println ("The time is "+ new Date ()));
t.start();
JOptionPane.showMessageDialog (null,"Quit program?");
System.exit (0);
}
} //运行结果
[Mercury, Venus, Mars, Jupiter, Saturn, Uranus, Neptune]
Sorted in dictionary order:
[Jupiter, Mars, Mercury, Neptune, Saturn, Uranus, Venus]
Sorted by length:
[Mars, Venus, Saturn, Uranus, Jupiter, Mercury, Neptune]
The time is Mon Nov 20 19:58:41 CST 2017
The time is Mon Nov 20 19:58:42 CST 2017
二、函数式接口
对于只有一个抽象方法的接口，需要这种接口的对象时，就可以提供一个lambda表达式。这种接口称为函数式接口（functional interface）。
三、方法的引用
要用 :: 操作符分隔方法名与对象或类名。主要有三种情况：
- object::instanceMethod
- Class::staticMethod
- Class::instanceMethod
在前两种情况中，方法引用等价于提供方法参数的lambda表达式。如：
System.out::println 等价于 x -> System.out.println(x);
Math::pow 等价于（x,y） -> Math.pow(x,y)。
对于第三种情况下，第一个参数会成为方法的目标，如：
String::compareToIgnoreCase 等同于(x,y) -> x.compareToIgnoreCase(y)。
示例：
import java.util.List;
import java.util.ArrayList; public class Java8Tester {
public static void main(String args[]){
List names = new ArrayList(); names.add("Google");
names.add("Runoob");
names.add("Taobao");
names.add("Baidu");
names.add("Sina"); names.forEach(System.out::println);
}
}
四、构造器引用
构造器引用与方法引用类似，只不过方法名为new。如：
ArrayList<String> names = ...；
Stream<Person> stream = names.stream().map(Person::new);
List<Person> people = stream.collect(Collectors.toList());
map方法会为各个列表元素调用Person（String）构造器，如果有多个构造器，编译器会选择有一个String参数的构造器，因为上下文推导出这是在对一个字符串调用构造器。
又如：int[]::new 是一个构造器引用，它有一个参数，即数组的长度。这等价于lambda表达式 x -> new int[x] 。
五、变量作用域
在lambda表达式中捕获的变量必须实际上是最终变量（即这个变量初始之后就不会再为它赋新值）；
下面做法是不合法的：
public static void countDowm(int start,int delay){
ActionListener listener = event -> {
start--;//Error:Can't mutate captured variable
System.out.println(start);
};
new Timer(delay,listener).start();
}
在lambda表达式中声明与一个局部变量同名的参数或局部变量是不合法的。如：
Path first = Paths.get("/urs/bin");
Comparator<String> comp =
(first,second) -> first.length() - second.length();
//Error:Variable first already defined
六、处理lambda表达式
使用lambda表达式的重点是延迟执行（deferred execution）。原因如：
- 在一个单独的线程中运行代码；
- 多次运行代码；
- 在算法的适当位置运行代码（如，排序中的比较操作）；
- 发生某种情况下执行代码（如，点击了一个按钮，数据到达，等待）；
- 只在必要时运行代码；
如重复一个动作n次：
repeat(10,()-> System.out.println("Hello World!"));