扫二维码与项目经理沟通
我们在微信上24小时期待你的声音
解答本文疑问/技术咨询/运营咨询/技术建议/互联网交流
这篇文章给大家介绍Java8中Lambda表达式如何使用，内容非常详细，感兴趣的小伙伴们可以参考借鉴，希望对大家能有所帮助。
创新互联建站主营八步网站建设的网络公司,主营网站建设方案,手机APP定制开发,八步h5成都微信小程序搭建,八步网站营销推广欢迎八步等地区企业咨询
Lambda表达式是一个可传递的代码块，可以在以后执行一次或多次；
// Java8之前：旧的写法
Runnable runnable = new Runnable() {
@Override
public void run() {
System.out.println("old run");
}
};
Thread t = new Thread(runnable);
// Java8之后：新的写法
Runnable runnable1 = ()->{
System.out.println("lambda run");
};
Thread t1 = new Thread(runnable1);
下面分别说下语法中的三个组成部分
参数: ( Dog dog )
参数类型可省略（当编译器可以自动推导时），比如Comparator,可以推导出a,b都为String
当参数类型可省略，且只有一个参数时，括弧也可以省略（但是个人习惯保留）
符号： ->
主体：{ System.out.println("javalover"); }
如果是一条语句，则需要加大括号和分号{;}（比如上图所示）
如果是一个表达式，则直接写，啥也不加（比如a.length()- b.length()）
为了简化代码
因为Java是面向对象语言，所以在lambda出现之前，我们需要先构造一个对象，然后在对象的方法中实现具体的内容，再把构造的对象传递给某个对象或方法
但是有了lambda以后，我们可以直接将代码块传递给对象或方法
现在再回头看下开头的例子
可以看到，用了lambda表达式后，少了很多模板代码，只剩下一个代码块（最核心的部分）
就是只定义了一个抽象方法的接口
正例：有多个默认方法，但是如果只有一个抽象方法，那它就是函数式接口，示例代码如下
@FunctionalInterface
public interface FunctionInterfaceDemo {
void abstractFun();
default void fun1(){
System.out.println("fun1");
}
default void fun2(){
System.out.println("fun2");
}
}这里的注解@FunctionalInterface可以省略，但是建议加上，就是为了告诉编译器，这是一个函数式接口，此时如果该接口有多个抽象方法，那么编译器就会报错
反例：比如A extends B，A和B各有一个抽象方法，那么A就不是函数式接口，示例代码如下
// 编译器会报错，Multiple non-overriding abstract methods found in XXX
@FunctionalInterface
public interface NoFunctionInterfaceDemo extends FunctionInterfaceDemo{
void abstractFun2();
}上面的父接口FunctionInterfaceDemo中已经有了一个抽象方法，此时NoFunctionInterfaceDemo又定义了一个抽象方法，结果编译器就提示了：存在多个抽象方法
在Java8之前，其实我们已经接触过函数式接口
比如Runnable 和 Comparable
只是没有注解@FunctionalInterface。
那这个函数式接口要怎么用呢？
配合lambda食用，效果最佳（就是把lambda传递给函数式接口），示例代码如下：
new Thread(() -> System.out.println("run")).start();其中用到的函数式接口是Runnable
就是把行为定义成参数，行为就是函数式接口
类似泛型中的类型参数化
行为参数化，通俗点来说：
就是用函数式接口做形参
然后传入接口的各种实现内容（即lambda表达式）作为实参
最后在lambda内实现各种行为（好像又回到多态的那一节了？这也是为啥多态是Java的三大特性的原因之一，应用太广泛了）
这样来看的话，行为参数化和设计模式中的策略模式有点像了（后面章节会分别讲常用的几种设计模式）
下面我们手写一个函数式接口来加深理解吧
下面我们循序渐进，先从简单的需求开始
第一步：比如我们想要读取某个文件，那可以有如下方法：
public static String processFile() throws IOException {
// Java7新增的语法，try(){}，可自动关闭资源，减少了代码的臃肿
try( BufferedReader bufferedReader =
new BufferedReader(new FileReader("D:\\JavaProject\\JavaBasicDemo\\test.txt"))){
return bufferedReader.readLine();
}
}可以看到，核心的行为动作就是 return bufferedReader.readLine();，表示读取第一行的数据并返回
那如果我们想要读取两行呢？三行？
第二步：这时就需要用到上面的函数式接口了，下面就是我们自己编写的函数式接口
@FunctionalInterface
interface FileReadInterface{
// 这里接受一个BufferedReader对象，返回一个String对象
String process(BufferedReader reader) throws IOException;
}可以看到，只有一个抽象方法process() ，它就是用来处理第一步中的核心动作（读取文件内容）
至于想读取多少内容，那就需要我们在lambda表达式中定义了
第三步：接下来我们定义多个lambda表达式，用来传递给函数式接口，其中每个lambda表达式就代表了一种不同的行为，代码如下：
// 读取一行 FileReadInterface fileReadInterface = reader -> reader.readLine(); // 读取两行 FileReadInterface fileReadInterface2 = reader -> reader.readLine() + reader.readLine();
第四步：我们需要修改第一步的processFile()，让其接受一个函数式接口，并调用其中的抽象方法，代码如下：
// 参数为第二步我们自己手写的函数式接口
public static String processFile(FileReadInterface fileReadInterface) throws IOException {
try( BufferedReader bufferedReader =
new BufferedReader(new FileReader("./test.txt"))){
// 这里我们不再自己定义行为，而是交给函数式接口的抽象方法来处理，然后通过lambda表达式的传入来实现多个行为
return fileReadInterface.process(bufferedReader);
}
}第五步：拼接后，完整代码如下：
public class FileReaderDemo {
public static void main(String[] args) throws IOException {
// 第三步：
// lambda表达式1 传给 函数式接口：只读取一行
FileReadInterface fileReadInterface = reader -> reader.readLine();
// lambda表达式2 传给 函数式接口：只读取两行
FileReadInterface fileReadInterface2 = reader -> reader.readLine() + reader.readLine();
// 最后一步： 不同的函数式接口的实现，表现出不同的行为
String str1 = processFile(fileReadInterface);
String str2 = processFile(fileReadInterface2);
System.out.println(str1);
System.out.println(str2);
}
// 第四步： 读取文件方法，接受函数式接口作为参数
public static String processFile(FileReadInterface fileReadInterface) throws IOException {
try( BufferedReader bufferedReader =
new BufferedReader(new FileReader("./test.txt"))){
// 调用函数式接口中的抽象方法来处理数据
return fileReadInterface.process(bufferedReader);
}
}
// 第一步：
public static String processFile() throws IOException {
try( BufferedReader bufferedReader =
new BufferedReader(new FileReader("./test.txt"))){
return bufferReader.readLine();
}
}
}
// 第二步： 我们手写的函数式接口
@FunctionalInterface
interface FileReadInterface{
String process(BufferedReader reader) throws IOException;
}其实你会发现，我们手写的这个函数式接口，其实就是Function去除泛型化后的接口，如下所示：