Java知识点03：Lambda表达式
一、Lambda表达式简介
Lambda 表达式，也可称为闭包，它是推动 Java 8 发布的最重要新特性。
Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）。
使用 Lambda 表达式可以使代码变的更加简洁紧凑。
二、Lambda基本语法
箭头操作符：() ->{}
-
Java8中引入了一个新的操作符，"->"，该操作符称为箭头操作符或者Lambda操作符，箭头操作符将Lambda表达式拆分成两部分；
-
左侧: Lambda表达式的参数列表，对应的是接口中抽象方法的参数列表；
-
右侧: Lambda表达式中所需要执行的功能(Lambda体)，对应的是对抽象方法的实现；(函数式接口(只能有一个抽象方法))
-
Lambda表达式的实质是 对接口的实现；
举例说明：用Lambda表达式创建线程
Thread thread = new Thread(() -> {
for (int i = 0; i < 5; i++) {
System.out.println("Thread:"+i);
}
});
thread.start();
三、Lambda表达式的具体实现方式
- 第一步，先定义几个接口，并且实现相应的方法
package com.study.lambda;
/**
* @Author gaojunlong
* @Date 2020/9/9
* @Time 9:21
* @Version 1.0
*/
//无参数，无返回值
@FunctionalInterface
public interface NoReturnNoParam {
void myNoReturnNoParam();
}
//无参数，有返回值
@FunctionalInterface
interface ReturnNoParam{
int myReturnNoParam();
}
//一个参数，无返回值
@FunctionalInterface
interface NoReturnOneParam{
void myNoReturnOneParam(int a);
}
//一个参数，有返回值
@FunctionalInterface
interface ReturnOneParam{
int myReturnOneParam(int a);
}
//多个参数，无返回值
@FunctionalInterface
interface NoReturnMoreParam{
void myNoReturnMoreParam(int a, int b);
}
//多个参数，有返回值
@FunctionalInterface
interface ReturnMoreParam{
int myReturnMoreParam(int a, int b);
}
- 第二步，用Lambda表达式实现接口及方法
package com.study.lambda;
/**
* @Author gaojunlong
* @Date 2020/9/9
* @Time 9:45
* @Version 1.0
*/
public class MyTest01 {
public static void main(String[] args) {
//无参数，无返回值
NoReturnNoParam noReturnNoParam = () -> {
System.out.println("NoReturnNoParam");
};
noReturnNoParam.myNoReturnNoParam();
System.out.println();
//无参数，有返回值
ReturnNoParam returnNoParam = () -> {
System.out.println("ReturnNoParam");
return 1;
};
int result = returnNoParam.myReturnNoParam();
System.out.println("return "+result);
System.out.println();
//一个参数无返回值
NoReturnOneParam noReturnOneParam = (int a) -> {
System.out.println("NoReturnOneParam: "+a);
};
noReturnOneParam.myNoReturnOneParam(8);
System.out.println();
//一个参数有返回值
ReturnOneParam returnOneParam = (int b) -> {
System.out.println("ReturnOneParam: "+b);
return 1;
};
int result1 = returnOneParam.myReturnOneParam(10);
System.out.println("result1: "+result1);
System.out.println();
//多个参数无返回值
NoReturnMoreParam noReturnMoreParam = (int x, int y) -> {
System.out.println("NoReturnMoreParam: {" + x +": " + y + "}" );
};
noReturnMoreParam.myNoReturnMoreParam(8,10);
System.out.println();
//多个参数有返回值
ReturnMoreParam returnMoreParam = (int num1, int num2) -> {
System.out.println("NoReturnMoreParam: {" + num1 +": " + num2 + "}" );
return num1 + num2;
};
int result2 = returnMoreParam.myReturnMoreParam(8,10);
System.out.println("result2:"+result2);
}
}
- 第三步，简化操作
简化一：只有一个参数类型时，可以去掉参数类型（int、String等类型）
简化二：只有一个变量参数时，可以去掉括号（）
简化三：只有一行代码时，可以去掉花括号{}
四、Lamdba表达式和其他表达式的区别
- 先定义一个函数式接口，在接口中定义一个无参无返回接口
//1、定义一个函数式接口，并在接口中定义一个无参无返回的接口
@FunctionalInterface
interface ILike{
void lambda();
}
- 第一种方法，在主类外部定义一个实现类，实现函数式接口，然后在主函数中调用该类，然后实现方法。
//2、实现类
class Like implements ILike{
@Override
public void lambda() {
System.out.println("I like lambda1");
}
}
//在主函数中实例化实现类，并调用该类的实现方法
public static void main(String[] args) {
ILike like = new Like();
like.lambda();
}
- 第二种方法，在主类中使用静态内部类实现函数式接口，然后实例化静态内部类，并实现其方法。
//3、静态内部类
static class Like2 implements ILike{
@Override
public void lambda() {
System.out.println("I like lambda2");
}
}
//在主类中调用方法
public static void main(String[] args) {
ILike like = new Like2();
like.lambda();
}
- 第三种方法，在主函数中定义局部内部类，然后调用实现方法
public static void main(String [] args){
//4、局部内部类
class Like3 implements ILike{
@Override
public void lambda() {
System.out.println("I like lambda3");
}
}
like = new Like3();
like.lambda();
}
- 第四种方法，使用匿名内部类进行实现
public static void main(String[] args) {
//5、匿名内部类
like = new ILike() {
@Override
public void lambda() {
System.out.println("I like lambda4");
}
};
like.lambda();
}
- 第五种方法，使用Lambda表达式实现
public static void main(String[] args) {
//6、lambda表达式
like = () ->{
System.out.println("I l;ike lambda5");
};
like.lambda();
}
完整代码：
/**
* @Author gaojunlong
* @Date 2020/8/27
* @Time 11:18
* @Version 1.0
*/
public class TestLamdba {
//第二个方法、静态内部类
static class Like2 implements ILike{
@Override
public void lambda() {
System.out.println("I like lambda2");
}
}
public static void main(String[] args) {
ILike like = new Like();
like.lambda();
like = new Like2();
like.lambda();
//第三个方法、局部内部类
class Like3 implements ILike{
@Override
public void lambda() {
System.out.println("I like lambda3");
}
}
like = new Like3();
like.lambda();
//第四个方法、匿名内部类
like = new ILike() {
@Override
public void lambda() {
System.out.println("I like lambda4");
}
};
like.lambda();
//第五个方法，lambda表达式
like = () ->{
System.out.println("I l;ike lambda5");
};
like.lambda();
}
}
//定义一个函数式接口
@FunctionalInterface
interface ILike{
void lambda();
}
//第一种方法，实现类
class Like implements ILike{
@Override
public void lambda() {
System.out.println("I like lambda1");
}
}
运行结果：
I like lambda1
I like lambda2
I like lambda3
I like lambda4
I like lambda5