Lambda 表达式
Lambda表达式本质上是一个匿名方法。常见的一个例子是，在 IDEA + JDK8 的环境下按照Java传统的语法规则编写一个线程：
new Thread(new Runnable() {
@Override
public void run() {
System.out.println("Hello World!");
}
});
IDEA会给出提示 Anonymous new Runnable() can be replaced with lambda less... (Ctrl+F1) ，说匿名内部类可以使用 Lambda 表达式替换。
使用 Lambda 表达式则只需要使用一句话就可代替上面使用匿名类的方式。
new Thread(() -> System.out.println("Hello World!"));
在这个例子中，传统的语法规则，我们是将一个匿名内部类作为参数进行传递，我们实现了Runnable接口，并将其作为参数传递给Thread类，这实际上我们传递的是一段代码，也即我们将代码作为了数据进行传递，这就带来许多不必要的“样板代码”。
在JDK8之前，Java是不支持函数式编程的，所谓的函数编程，即可理解是将一个函数（也称为“行为”）作为一个参数进行传递。通常我们提及得更多的是面向对象编程，面向对象编程是对数据的抽象（各种各样的POJO类），而函数式编程则是对行为的抽象（将行为作为一个参数进行传递）。在JavaScript中这是很常见的一个语法特性，但在Java中将一个函数作为参数传递这却行不通，好在JDK8的出现打破了Java的这一限制。
如上例所见，Lambda表达式一共有三部分组成：参数列表，箭头（->），以及一个表达式或语句块。
Lambda 表达式和函数式接口结合
什么场景下可以使用 Lambda 表达式？
能够接收 Lambda 表达式的参数类型，是一个只包含一个抽象方法的接口。只包含一个抽象方法的接口为“函数式接口”。
例如上例，Runnable 接口只包含一个抽象方法，所以它被称为“函数式接口”，所以它可以使用 Lambda 表达式来代替匿名内部类，作为 Thread 的构造参数。
函数式接口有无入参和有无返回值，可分为四种情形：
无参无返回值
有参无返回值
无参有返回值
有参有返回值
Lambda 表达式和这四种形式的函数式接口结合也就有四种情况；
无参无返回值
package com.boomoom; @FunctionalInterface
public interface InterfaceWithNoParam {
void run();
}
package com.boomoom;
import org.junit.Test;
public class FunctionInterfaceTest {
//匿名内部类
InterfaceWithNoParam param1 = new InterfaceWithNoParam() {
@Override
public void run() {
System.out.println("通过匿名内部类实现run()");
}
};
//Lambda表达式
//空括号表示无参
InterfaceWithNoParam param = () -> System.out.println("通过Lambda表达式实现run()") ;
@Test
public void testInterfaceWithNoParam() {
this.param.run();
this.param1.run();
}
}
通过Lambda表达式实现run()
通过匿名内部类实现run()
有参无返回值
package com.boomoom; @FunctionalInterface
public interface InterfaceWithParam {
void run(String s);
}
package com.boomoom;
import org.junit.Test;
public class FunctionInterfaceTest {
InterfaceWithParam param = new InterfaceWithParam() {
@Override
public void run(String s) {
System.out.println("通过" + s + "实现run(String)");
}
};
InterfaceWithParam param1 = (String s) -> System.out.println("通过" + s + "实现run(String)");
@Test
public void testInterfaceWithParam() {
this.param.run("匿名类");
this.param1.run("Lambda");
}
}
通过匿名类实现run(String)
通过Lambda实现run(String)
Lambda 表达式“(String) -> Sysout.out.println("通过" + s + "实现run(String)")”，左边传递的是参数，此处指明参数类型，也可不指定，通过上下文进行类型推导；但在有些情况下不能推导出参数类型（在编译时不能推导通常IDE会提示），此时则需要指明参数类型。我个人建议，任何情况下指明函数的参数类型。
哪种情况不能推导出参数类型呢？就是函数接口是一个泛型的时候。
@FunctionalInterface
public interface InterfaceWithParam<T> {
void run(T param);
}
无参有返回值
package com.boomoom; @FunctionalInterface
public interface InterfaceUnVoidWithNoParam {
String run();
}
package com.boomoom;
import org.junit.Test;
public class FunctionInterfaceTest {
InterfaceUnVoidWithNoParam interfaceUnVoidWithNoParam = new InterfaceUnVoidWithNoParam() {
@Override
public String run() {
return "Hello 匿名内部类!";
}
};
InterfaceUnVoidWithNoParam interfaceUnVoidWithNoParam1 = () -> "Hello Lambda!";
@Test
public void test() {
System.out.println("返回结果是："+ this.interfaceUnVoidWithNoParam.run());
System.out.println("返回结果是："+ this.interfaceUnVoidWithNoParam1.run());
}
}
返回结果是：Hello 匿名内部类!
返回结果是：Hello Lambda!
有参有返回值
package com.boomoom; @FunctionalInterface
public interface InterfaceUnVoidWithParam {
String run(Integer i);
}
package com.boomoom;
import org.junit.Test;
public class FunctionInterfaceTest {
InterfaceUnVoidWithParam interfaceWithParams = new InterfaceUnVoidWithParam() {
@Override
public String run(Integer integer) {
return String.valueOf(integer);
}
};
InterfaceUnVoidWithParam interfaceWithParams1 = (Integer integer) -> String.valueOf(integer);
@Test
public void test() {
System.out.println("您输入的是："+ this.interfaceWithParams.run(1));
System.out.println("您输入的是："+ this.interfaceWithParams1.run(2));
}
}
您输入的是：1
您输入的是：2
这四种基本情况已经大致清楚了，特别是需要弄清，什么时候可以使用 Lambda 表达式代替匿名内部类，也就是 Lambda 表达式的应用场景是函数式接口。Lambda 表达式这一新特性在 JDK8 中的引入，更大的好处则是集合 API 的更新，新增的 Stream 类库，使得我们在遍历使用集合时不再像以往那样不断地使用 for 循环。
JDK8 使用集合
示例：计算来自“hangzhou”的学生数量有多少。
在JDK8 前的代码：
for (Student student : studentList) {
if (student.getCity().equals("hangzhou")) {
count++;
}
}
JDK8 使用集合的正确姿势：
count = studentList.stream().filter((student -> student.getCity().equals("hangzhou"))).count();
API 的使用“难度”恰似提高了，实际只是不熟悉而已。传统迭代的方式需要阅读完整个循环才能明白代码逻辑，JDK8 通过流的方式则可以望文生义且代码量大大减小。
其中最为重要的是 Stream 流。Stream 的是通过函数式编程方式实现的在集合类上进行复杂操作的工具。关于 Stream 的用法和实现方式，详见此篇。使用JDK8的开发环境进行开发，尽量使用新的集合操作 API。
参考：https://www.cnblogs.com/yulinfeng/p/8452379.html
http://www.runoob.com/java/java8-lambda-expressions.html