java 莱姆达表达式是java8的新特性，java lambda表达式是java的迈向函数式编程的第一步。因此，java的lambda表达式其实是一个方法，它可以不从属于任何一个类。java表达式可以作为一个参数，就好像它是一个对象一样。它可以在需求时被执行。
java的lambda表达式通常被用于实现简单的事件监听器或回调函数，或者和javaStreamApi一起实现函数式编程。
1.java Lambda 以及单一方法接口
函数式编程通常被用于实现事件监听器。java中的事件监听器通常被定义为含有单一方法的接口，这里有一个虚构的单一方法接口：
public interface StateChangeListener {
public void onStateChange(State oldState, State newState);
}
这个java接口定义了一个单一的方法，当状态改变时，会调用这个方法。
在java7中，为了监听状态的改变，你就不得不实现这个接口，想象一下，你有一个类叫： StateOwner,它可以注册状态事件监听器，这是一个例子：
public class StateOwner {
public void addStateListener(StateChangeListener listener) { ... }
}
在java7中，你可以使用匿名内部类去添加一个事件监听器，就像这样：
StateOwner stateOwner = new StateOwner();
stateOwner.addStateListener(new StateChangeListener() {
public void onStateChange(State oldState, State newState) {
// do something with the old and new state.
}
});
首先，创建一个StateOwner实例，然后把StateChangeListener接口的匿名实现类被作为一个监听器添加到StateOwner实例中。
但是在java8中，你可以使用javaLambda表达式来添加一个事件监听器，就像这样：
StateOwner stateOwner = new StateOwner();
stateOwner.addStateListener((oldState, newState) -> System.out.println("State changed"));
lambda表达式就是下面的这一部分：
(oldState, newState) -> System.out.println("State changed")
我们要求lambda表达式要匹配addStateListener()方法的参数类型，如果lambda表达式匹配该参数类型(在这里，即：StateChangeListener接口)。那么，这个lambda表达式就会被转化为一个实现了StateChangeListener接口的函数。
java的lambda表达式只适用于那些匹配单一方法接口的类。在上面的例子中，lambda表达式被当做参数使用，而参数类型是StateChangeListener接口。这个接口只有一个方法，因此该lambda表达式能够成功地匹配StateChangeListener接口。
2.使lambda表达式和接口匹配matching lambdas to interface
一个单方法的接口有时也被称为 函数式接口，把一个java表达式和一个函数式接口相匹配要分成下面三步：
.这个接口只有一个抽象方法吗？？？
.lambda表达式的参数和方法的参数匹配吗？？？
.lambda表达式的返回值类型和方法的返回值类型匹配吗？？？
如果这三个问题的答案都是Yes的话，那么这个给定的lambda表达式就能成功地匹配此接口。
3.含有默认和静态方法的接口
从java8开始，一个java接口里面可以同时包含默认方法和静态方法。默认方法和静态方法的实现可以直接在接口的声明。这也就意味着，java的lambda表达式也可以适用于包含超过一个方法的接口-只要该接口里只有一个未实现的方法即可。
换句话说，接口仍然是函数式接口，即使他包含默认函数和静态函数，只要这个接口理由只有一个未实现的方法就行。
下面的这个接口，可以用一个lambda表达式实现：
public interface MyInterface {
void printIt(String text);
default public void printUtf8To(String text, OutputStream outputStream){
try {
outputStream.write(text.getBytes("UTF-8"));
} catch (IOException e) {
throw new RuntimeException("Error writing String as UTF-8 to OutputStream", e);
}
}
static void printItToSystemOut(String text){
System.out.println(text);
}
}
4.Lambda表达式 VS 匿名接口实现
虽然lambda表达式和匿名接口实现很相像，但是他们之间还是有些不同的。最大的区别是，一个匿名接口实现有状态(成员变量)，然而lambda表达式却没有。看下这个接口：
public interface MyEventConsumer {
public void consume(Object event);
}
这个接口可以使用一个匿名接口实现来实现，就像这样：
MyEventConsumer consumer = new MyEventConsumer() {
public void consume(Object event){
System.out.println(event.toString() + " consumed");
}
};
这个匿名接口实现MyEventConsumer 可以有它自己的内部状态，看下面这个：
MyEventConsumer myEventConsumer = new MyEventConsumer() {
private int eventCount = 0;
public void consume(Object event) {
System.out.println(event.toString() + " consumed " + this.eventCount++ + " times.");
}
};
可以看到MyEventConsumer的匿名实现现在已经有了一个字段域eventCount。但是lambda表达式却不能有这样的域字段。因此，lambda表达式又被说成是无状态的。
5.Lambda表达式的类型推断
在java8之前，如果你要实现一个接口实现，你不得不指定要实现哪个接口。这里有一个匿名接口实现的例子：
stateOwner.addStateListener(new StateChangeListener() {
public void onStateChange(State oldState, State newState) {
// do something with the old and new state.
}
});
但是如果使用lambda表达式的话，它的类型可以根据附近的代码推到出来。例如，参数的接口类型可以从方法的声明addStateListener()那里推导出来.这被称为类型推断。
编译器会查找这个参数所属的类型-在这个例子中，就是方法定义。下面这个例子就可以看出，我们在lambda表达式中并未提及StateChangeListener接口：
stateOwner.addStateListener(
(oldState, newState) -> System.out.println("State changed")
);
在lambda表达式里面，参数类型也能直接推断出来。在上面这个例子中，编译器就是根据onStateChange()方法的声明来确定参数类型的。因此，lambda表达式中的oldState和newState的类型也可以从onStateChange()方法的声明中推断出来。
6.Lambda参数
由于java的lambda表达式实际上就是一个方法，所以，lambda表达式可以像方法一样去接收参数。 上面例子中的lambda表达式中的(oldState,newState)就表明了lambda表达式要接收的参数。这些参数都得和接口中方法的参数保持一致。在这个例子中，这些参数必须要匹配StateChangeListener接口的onStateChange()方法中的参数。
public void onStateChange(State oldState, State newState);
7.零参数
如果和lambda表达式匹配的方法不接收任何参数，那你可以写个像这样的lambda表达式：
() -> System.out.println("Zero parameter lambda");
这就是表明该lambda表达式不接收任何参数。
8. 一个参数
如果匹配lambda表达式的方法只接收一个参数的话，你可以写一个这样的lambda表达式：
(param) -> System.out.println("One parameter: " + param);
可以注意到，参数被放在圆括号里面。另外，当一个lambda表达式接收一个参数时，你可以省略圆括号，就像这样：
param -> System.out.println("One parameter: " + param);
9.多个参数
如果lambda表达式匹配的方法接收多个参数的话，那么参数需要放置到圆括号里，就像下面的这样：
(p1, p2) -> System.out.println("Multiple parameters: " + p1 + ", " + p2);
只有当方法只接收一个参数时，圆括号才能被省略。
10.参数类型
有时为lambda表达式指定参数类型是非常必要的(如果这个编译器不能从接口方法中推断出参数类型的话)。不要担心，如果出现这种情况，编译器会提示你。这里有个lambda表达式参数类型的例子：
(Car car) -> System.out.println("The car is: " + car.getName());
正如你看到的，名为car的参数类型被写在了参数名字的前面，就像你在方法里面声明了一个参数一样。
11.Lambda函数体
lambda表达式体，也即是：它所表示的方法体被指定在了"->"的右边，这里就是一个例子：
(oldState, newState) -> System.out.println("State changed")
如果你的lambda表达式需要由多行构成的话，你可以把lambda表达式体放在{}中括号里面包起来，这里有个例子：
(oldState, newState) -> {
System.out.println("Old state: " + oldState);
System.out.println("New state: " + newState);
}
12.从Lambda表达式返回一个值
你可以从lambda表达式返回值，就像你可以从方法里面获取一个返回值一样。你只需要在lambda函数体里面增加一个return语句就可以啦。
(param) -> {
System.out.println("param: " + param);
return "return value";
}
在这个例子中，你lambda表达式做的事就是计算出一个返回值，然后把它返回，你也能用一个更简短方式指定返回值：
除了这样写：
(a1, a2) -> { return a1 > a2; }
你也可以这样写：
(a1, a2) -> a1 > a2;
编译器会计算出来 a1 > a2是一个lambda表达式的返回值。
13.变量捕捉
在某些情况下，lambda表达式也能够访问那些声明在lambda函数体外面的变量。我这里有一段代码：
Java 可以获取以下三种类型的变量：
.局部变量
.实例变量
.静态变量
我们将在下个章节中详细讲述。
13.1本地局部变量捕获
java的lambda表达式可以获取在lambda函数体外声明的本地局部变量的值。为了展示它，我们先看一个单一方法的接口：
public interface MyFactory {
public String create(char[] chars);
}
现在，我们看一下，lambda表达式如何实现这个接口的：
MyFactory myFactory = (chars) -> {
return new String(chars);
};
现在这个lambda表达式仅仅是引用了传递给它的参数值，但是我们也能换一种写法，下面有一个更新版本：
String myString = "Test";
MyFactory myFactory = (chars) -> {
return myString + ":" + new String(chars);
};
正如你所看到的，在lambda表达式体重引用了本地局部变量myString的值。
3.2 实例变量捕获
lambda表达式也能使用lambda表达式所在对象的实例变量。下面有个例子：
public class EventConsumerImpl {
private String name = "MyConsumer";
public void attach(MyEventProducer eventProducer){
eventProducer.listen(e -> {
System.out.println(this.name);
});
}
}
可以注意到，对name的引用this.name位于lambda表达式的内部。这样做的话，lambda表达式就能够在EventConsumerImpl的内部访问name实例量(域变量)。更甚之，在获取到它的访问之后，我们也能够改变此实例变量的值，并且它的值也能被映射到lambda表达式的内部。
这里的this，实际上是一种域，它和java的匿名接口实现有所不同。一个匿名接口实现也可以有它自己实例变量，并且可以通过this应用进行访问。但是，对于lambda表达式来说，lambda表达式不能有自己的实例变量，因此，this总是指向当前对象。
注意： 以上的事件消费者的设计不是特别的优美简洁，我那样做仅仅是为了描述一个访问实例变量的场景。
13.3 静态变量捕捉
一个lambda表达式也能捕捉静态变量。这并不吃惊，因为静态变量在整个应用的内部都能访问静态变量(只要该静态变量是可访问的 )。
下面有一个例子：
public class EventConsumerImpl {
private static String someStaticVar = "Some text";
public void attach(MyEventProducer eventProducer){
eventProducer.listen(e -> {
System.out.println(someStaticVar);
});
}
}
静态变量的值在被lambda表达式捕捉过之后，也允许修改。
14.方法引用作为lambda表达式
在上面的例子中，你的lambda表达式所做的事情就是 调用另一个方法并把参数传递给该lambda表达式。但是java的lambda表达式实现，提供了一种更简单的方式去表示一个方法调用。
首先，这里有一个单一方法的接口：
public interface MyPrinter{
public void print(String s);
}
紧接着，我们创建一个实现了MyPrinter接口的lambda表达式实例：
MyPrinter myPrinter = (s) -> { System.out.println(s); };
由于该lambda表达式只有一个单一的语句构成，所以实际上我们可以不用{}中括号来包裹。并且，由于这里lambda表达式只有一个参数，所以我们
可以忽略掉参数的()标签。就像这样：
MyPrinter myPrinter=s -> System.out.println(s);
由于上面的lambda表达式做的事情就是把string参数转寄给System.out.println()方法，所以我们可以用一个方法引用来替换上面的lambda表达式。
just looks:
MyPrinter myPrinter = System.out::println;
可以看到，俩个冒号:: ,这就是向编译器表明，这是一个方法引用并且这个方法引用就是俩个冒号::之后的东西。不管拥有该引用方法的是类还是对象，它都是位于俩个冒号::之前的类或者对象。
你可以参考下面的几种方法类型：
.静态方法
.实例方法
.参数对象上的实例方法
.构造器
上面的每一种方法引用都会在下面的章节中讲述。
14.1 静态方法引用
最简单的方法引用就是静态方法引用。这是一个简单的单函数接口:
public interface Finder {
public int find(String s1, String s2);
}
这有一个静态方法：
public class MyClass{
public static int doFind(String s1, String s2){
return s1.lastIndexOf(s2);
}
}
下面我们就用一个lambda表达式来调用这个方法：
Finder finder = MyClass::doFind;
由于Finder.find()方法的参数和MyClass.doFind()方法匹配，所以就能创建一个实现Finder.find()方法的lambda表达式，同时 引用了MyClass.doFind()方法。
14.2 参数方法引用
14.3实例方法引用
第三点，我们也能从一个lambda表达式的定义处引用一个实例方法，首先，先看一个单方法接口定义：
public interface Deserializer {
public int deserialize(String v1);
}
这个接口代表了一个能把一个String序列化为一个int的组件。
现在，看看这个StringConverter类：
public class StringConverter {
public int convertToInt(String v1){
return Integer.valueOf(v1);
}
}
convertToInt()方法和Deserializer类的deserialize()方法有着同样的方法签名，正是由于这样，我们可以创建一个StringConverter
实例，，并且从一个lambda表达式中引用它：
StringConverter stringConverter = new StringConverter();
Deserializer des = stringConverter::convertToInt;
第一行的代码创建了一个StringConverter实例对象，第二行的lambda表达式引用了StringConverter 实例对象的convertToInt()方法。
14.4构造方法引用
最后，我们也能引用一个类的构造方法，你只需要在::new 的前面写上类名即可。就像这样：
MyClass::new
如果想看一下，作为lambda表达式如何使用构造方法的话，看下这个接口的定义：
public interface Factory {
public String create(char[] val);
}
这个create()方法能够匹配String类的某一个构造方法的方法签名，因此，这个构造方法可以作为一个lambda表达式使用。这里有一个例子：
Factory factory = String::new;
上面的这段代码其实就等同于：
Factory factory = chars -> new String(chars);
