⚪ λ 希腊字母表中排序第十一位的字母, 英语名称为Lambda
⚪ 避免匿名内部类定义过多
⚪ 其实质属于函数式编程的概念
⚪ 也可称为闭包
⚪ Lambda允许把一个函数作为方法的参数（函数作为参数传递进方法中）。
Lambda是在jdk8之后出现的所以现在用到的还是比较多的, 需要学习
◻️ 为什么要使用Lambda表达式
◽避免匿名内部类定义过多
◽可以使代码更加简洁紧凑
◽去掉了一堆没有意义的代码, 只留下核心的逻辑。
💬 也许你会说, 我看了Lambda表达式, 不但不觉得简洁, 反而觉得更乱了, 看不懂了. 那是因为我们还没有习惯, 用的多了, 看习惯了, 就好了。学习就是这样的一个过程
语法
lambda 表达式的语法格式如下：
(parameters) -> expression [表达式]
或
(parameters) -> statement [语句]
或
(parameters) -> { statements; }a-> System.out.println("i like lambda-->"+a)
◻️ 理解Functional Interface (函数式接口) 是学习Java8 lambda表达式的关键所在。
函数式接口定义:
◽任何接口, 如果只包含唯一一个抽象方法, 那么它就是一个函数式接口。
public interface Runnable {
public abstract void run(); //抽象方法
}◽对于函数式接口, 我们可以通过 Lambda表达式 来创建该接口的对象。
如果到这里某些小伙伴还是听不懂的话, 没关系, 我们上代码推动着你讲解一下你就懂了:
Lambda表达式推导
1. 首先需要定义一个函数式接口
2. 实现接口的方法 → 一步一步简化方式实现
- 第一个实现方法 :创建实现类, 实现
- 第二个实现方法 :静态内部类, 实现
- 第三个实现方法 :局部内部类, 实现
- 第四个实现方法 :匿名内部类, 实现
- 第五个实现方法 :Lambda表达式, 实现
3. 创建接口对象 接口调用实现类
package cn.lambda;
/**
* @BelongsProject: staticthread
* @BelongsPackage: cn.lambda
* @Author: Jean_z
* @CreateTime: 2024-05-14 10:52
* @Description: TODO: 推导 Lambda表达式
* @Version: 1.0
*/
public class TestLambda {
// 3. 静态内部类
static class Like2 implements ILike{
@Override
public void lambda() {
System.out.println("i like lambda2");
}
}
// 3. main
public static void main(String[] args) {
// 3. 创建接口对象 接口调用实现类
ILike like = new Like();
like.lambda();
like = new Like2();
like.lambda();
// 4. 局部内部类
class Like3 implements ILike {
@Override
public void lambda() {
System.out.println("i like lambda3");
}
}
like = new Like3();
like.lambda();
// 5. 匿名内部类, 没有类的名称,必须借助接口或者父类
like = new Like() {
@Override
public void lambda() {
System.out.println("i like lambda4");
}
};
like.lambda();
// 6. 用Lambda简化 Lambda是在jdk8之后出现的所以现在用到的还是比较多的, 需要学习
like = ()-> {
System.out.println("i like lambda5");
};
like.lambda();
}
}
//1. 首先需要定义一个函数式接口
interface ILike {
void lambda();
}
//2. 实现类, 实现lambda方法
class Like implements ILike {
@Override
public void lambda() {
System.out.println("i like lambda");
}
}如果你还是不理解那我们再来写一个例子
我们可以看到我们以上代码定义的函数式接口是没有参数的, 那我们来写一个不同的例子, 带参数的函数式接口.
这次我们一个方式一个方式的写, 看着不会太乱, 更好理解
Lambda表达式推导详解
这里我们定义了一个int类型的参数
1. 定义一个带参数的函数接口
2. 实现接口方法
3. 创建接口对象 接口调用实现类
4. 传递参数
-
第一个实现方法 :创建实现类, 实现
package cn.lambda;
/**
* @BelongsProject: staticthread
* @BelongsPackage: cn.lambda
* @Author: Jean_z
* @CreateTime: 2024-05-14 12:11
* @Description: TODO
* @Version: 1.0
*/
public class TestLambda2 {
public static void main(String[] args) {
// 创建接口对象
ILove love = new Love();
// 传递参数
love.love(2);
}
}
// 1. 定义一个带参数的函数式接口
interface ILove {
void love(int a); //定义一个int类型的参数
}
//2. 实现类
class Love implements ILove {
@Override
public void love(int a) {
System.out.println("i love you--->" + a);
}
}
-
第二个实现方法 :静态内部类, 实现
package cn.lambda;
/**
* @BelongsProject: staticthread
* @BelongsPackage: cn.lambda
* @Author: Jean_z
* @CreateTime: 2024-05-14 12:11
* @Description: TODO
* @Version: 1.0
*/
public class TestLambda2 {
//2. 静态实现类
static class Love implements ILove {
@Override
public void love(int a) {
System.out.println("i love you--->" + a);
}
public static void main(String[] args) {
// 实现love接口
ILove love = new Love();
// 传递参数
love.love(2);
}
}
}
// 1. 定义一个带参数的函数式接口
interface ILove {
void love(int a); //定义一个int类型的参数
}
-
第三个实现方法 :局部内部类, 实现
package cn.lambda;
/**
* @BelongsProject: staticthread
* @BelongsPackage: cn.lambda
* @Author: Jean_z
* @CreateTime: 2024-05-14 12:11
* @Description: TODO
* @Version: 1.0
*/
public class TestLambda2 {
public static void main(String[] args) {
//2. 局部内部类
class Love implements ILove {
@Override
public void love(int a) {
System.out.println("i love you--->" + a);
}
}
// 实现love接口
ILove love = new Love();
// 传递参数
love.love(2);
}
}
// 1. 定义一个带参数的函数式接口
interface ILove {
void love(int a); //定义一个int类型的参数
}
-
第四个实现方法 :匿名内部类, 实现
package cn.lambda;
/**
* @BelongsProject: staticthread
* @BelongsPackage: cn.lambda
* @Author: Jean_z
* @CreateTime: 2024-05-14 12:11
* @Description: TODO
* @Version: 1.0
*/
public class TestLambda2 {
public static void main(String[] args) {
// 实现love接口
// 匿名内部类
ILove love = new ILove(){
@Override
public void love(int a) {
}
};
// 传递参数
love.love(2);
}
}
// 1. 定义一个带参数的函数式接口
interface ILove {
void love(int a); //定义一个int类型的参数
}
匿名内部实现类推导再简化, 就是我们的Lambda表达式.
-
第五个实现方法 :Lambda表达式, 实现
如下图:
基于匿名内部类代码小编圈起来的代码都不用要了直接删掉!
- 只留下我们的参数和主体 就是我们的lambda表达式了
参数: int a;
主体: System.out.println()
package cn.lambda;
/**
* @BelongsProject: staticthread
* @BelongsPackage: cn.lambda
* @Author: Jean_z
* @CreateTime: 2024-05-14 12:11
* @Description: TODO
* @Version: 1.0
*/
public class TestLambda2 {
public static void main(String[] args) {
// 实现love接口
// lambda表达式实现
ILove love = (int a)-> {
System.out.println("i love lambda表达式");
};
// 传递参数
love.love(2);
}
}
// 1. 定义一个带参数的函数式接口
interface ILove {
void love(int a); //定义一个int类型的参数
}
那有些小伙伴就要问了:
💬 :既然可以简化这么多, 我们还能不能对它再简化呢?
👩💻:没问题
而且小编给大家扩充一下, Lambda表达式可以实现3种简化.但是也有条件的
简化 Lambda表达式
-
简化方式一:
1. 简化掉参数类型
package cn.lambda;
/**
* @BelongsProject: staticthread
* @BelongsPackage: cn.lambda
* @Author: Jean_z
* @CreateTime: 2024-05-14 12:11
* @Description: TODO
* @Version: 1.0
*/
public class TestLambda2 {
public static void main(String[] args) {
// 实现love接口
ILove love=null;
// lambda表达式实现
love = (int a)-> {
System.out.println("i love lambda表达式");
};
// Lambda表达式简化 1, 参数类型
love = (a)-> {
System.out.println("i love lambda表达式");
};
// 传递参数
love.love(2);
}
}
// 1. 定义一个带参数的函数式接口
interface ILove {
void love(int a); //定义一个int类型的参数
}
-
简化方式二:
2. 简化掉参数类型+括号
前提:
只有一个参数的情况下才可以去掉括号, 多个参数会报错. 加上括号即可
package cn.lambda;
/**
* @BelongsProject: staticthread
* @BelongsPackage: cn.lambda
* @Author: Jean_z
* @CreateTime: 2024-05-14 12:11
* @Description: TODO
* @Version: 1.0
*/
public class TestLambda2 {
public static void main(String[] args) {
// 实现love接口
ILove love=null;
// lambda表达式实现
love = (int a)-> {
System.out.println("i love lambda表达式");
};
// Lambda表达式简化 1, 参数类型
love = (a)-> {
System.out.println("i love lambda表达式");
};
// Lambda表达式简化 2, 简化括号
love = a-> {
System.out.println("i love lambda表达式");
};
// 传递参数
love.love(2);
}
}
// 1. 定义一个带参数的函数式接口
interface ILove {
void love(int a); //定义一个int类型的参数
}
-
简化方式三:
2. 简化掉参数类型+括号+花括号
前提:
只有一行代码的情况下
多个参数不能使用, 会报错 多个参数需要加上括号
package cn.lambda;
/**
* @BelongsProject: staticthread
* @BelongsPackage: cn.lambda
* @Author: Jean_z
* @CreateTime: 2024-05-14 12:11
* @Description: TODO
* @Version: 1.0
*/
public class TestLambda2 {
public static void main(String[] args) {
// 实现love接口
ILove love=null;
// lambda表达式实现
love = (int a)-> {
System.out.println("i love lambda表达式");
};
// Lambda表达式简化 1, 参数类型
love = (a)-> {
System.out.println("i love lambda表达式");
};
// Lambda表达式简化 2, 简化括号
love = a-> {
System.out.println("i love lambda表达式");
};
// Lambda表达式简化 3, 简化花括号
love = a-> System.out.println("i love lambda表达式" + a);
// 传递参数
love.love(2);
}
}
// 1. 定义一个带参数的函数式接口
interface ILove {
void love(int a); //定义一个int类型的参数
}
总结:
lambda表达式只能有一行代码的情况下才能简化成为一行, 如果有多行, 那就么就用代码块包裹.
前提是接口为函数时接口.
多个参数也可以去掉参数类型, 要去掉就全去掉, 必须加括号
