Lambda 表达式详解

🕗 发布于 2024-05-15 20:00 java 开发语言 Lambda表达式后端

⚪ λ 希腊字母表中排序第十一位的字母, 英语名称为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表达式只能有一行代码的情况下才能简化成为一行, 如果有多行, 那就么就用代码块包裹.

前提是接口为函数时接口.

多个参数也可以去掉参数类型, 要去掉就全去掉, 必须加括号

原文地址：https://blog.csdn.net/zzx_mn/article/details/138843255

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：【数组的度】leetcode,python
下一篇：AI网络爬虫：用kimichat自动批量提取网页内容

Spring WebFlux 响应式概述(1)
响应式编程是使用异步、事件驱动构建非阻塞式应用的，此类应用仅需要少量的线程用于横向扩展。该定义的关键一点是：借助背压技术，防止生产者压垮消费者。如服务A需要从服务B获取数据。对于响应式编程，服务A向服
阅读更多2024-10-09
ADAS中的安全性功能与舒适性功能总结
请注意，一些功能如自适应巡航控制（ACC）和交通拥堵辅助（TJA）既有安全性也有舒适性，既能提高驾驶安全又能减轻驾驶负担。
阅读更多2024-10-09
TCP（Transmission Control Protocol，传输控制协议）整理
TCP（Transmission Control Protocol，传输控制协议）是一种面向连接的、可靠的传输协议，它是OSI（Open System Interconnection，开放式系统互联）
阅读更多2024-10-09
网页前端开发之Javascript入门篇(8/9)：数组
什么是数组？答：数组是一种数据结构，它对应生活中的一种现象就是：队列。换句话说：数组在编程中就是用来存储带有队列特征的数据。
阅读更多2024-10-09
rpm软件包的制作方法
源码包制作成rpm包可以在centos系列系统上平移其他机器需要这个环境把包发过去就可以yum -y installnew_pkg_namerpm安装比较方便rpm包构建过程：第一步下载targz源码
阅读更多2024-10-09
成像基础 -- 景深计算
在这个例子中，当使用 50mm 焦距、f/2.8 光圈值，并对焦在 2 米远的物体上时，总景深约为45.92米前景深（最近清晰的距离）为12.08米后景深（最远清晰的距离）为58米。
阅读更多2024-10-09
HarmonyOS学习(十五)——数据管理(四) 用户首选项封装
Arkts preferences进行封装，支持初始化，增加，修改，删除，查询
阅读更多2024-10-09
鸿蒙--知乎评论
这里我们将采用组件化的思想进行开发。
阅读更多2024-10-09
【基础篇】一个键值数据库包含什么？
今天，在构造这个简单的键值数据库时，我们只需要关注整体架构和核心模块。这就相当于医学上在正式解剖人体之前，会先解剖一只小白鼠。我们通过剖析这个最简单的键值数据库，来迅速抓住学习和调优 Redis 的关
阅读更多2024-10-09
【数字图像处理】第2章数字图像处理基础，彩色图像，灰度图像，图像的采样与量化，图像文件格式，灰度直方图
【数字图像处理】第2章数字图像处理基础，彩色图像，灰度图像，图像的采样与量化，图像文件格式，灰度直方图
阅读更多2024-10-09

Lambda 表达式详解

◻️ 为什么要使用Lambda表达式

语法

函数式接口定义:

Lambda表达式推导

Lambda表达式推导详解

第一个实现方法 :创建实现类, 实现

第二个实现方法 :静态内部类, 实现

第三个实现方法 :局部内部类, 实现

第四个实现方法 :匿名内部类, 实现

第五个实现方法 :Lambda表达式, 实现

简化 Lambda表达式

简化方式一:

简化方式二:

简化方式三:

总结:

相关文章