Java·Lambda

news2024/10/7 8:23:27

文章目录

  • ⚽️1 背景⚽️
    • 🍏1.1 Lambda表达式的语法🍏
    • 🍎1.2 函数式接口🍎
  • 🏀2 Lambda表达式的基本使用🏀
    • 🍈2.1 语法精简🍈
  • 🏈3 变量捕获🏈
    • 🏆3.1 匿名内部类🏆
    • 🥇3.2 匿名内部类的变量捕获🥇
    • 🥈3.3 Lambda的变量捕获🥈
  • ⚾️4 Lambda在集合当中的使用⚾️
    • 🏄‍♀️4.1 Collection接口🏄‍♀️
    • 🏊‍♀️4.2 List接口🏊‍♀️
    • 🤽‍♀️4.3 Map接口🤽‍♀️
  • 🥎5 总结🥎

大家好，我是晓星航。今天为大家带来的是 Java·Lambda 相关的讲解！😀

⚽️1 背景⚽️

Lambda表达式是Java SE 8中一个重要的新特性。lambda表达式允许你通过表达式来代替功能接口。 lambda表达式就和方法一样,它提供了一个正常的参数列表和一个使用这些参数的主体(body,可以是一个表达式或一个代码块)。 Lambda 表达式（Lambda expression），基于数学中的λ演算得名，也可称为闭包（Closure） 。

🍏1.1 Lambda表达式的语法🍏

基本语法: (parameters) -> expression 或 (parameters) ->{ statements; }

Lambda表达式由三部分组成：

  1. paramaters：类似方法中的形参列表，这里的参数是函数式接口里的参数。这里的参数类型可以明确的声明也可不声明而由JVM隐含的推断。另外当只有一个推断类型时可以省略掉圆括号。
  2. ->：可理解为“被用于”的意思
  3. 方法体：可以是表达式也可以代码块，是函数式接口里方法的实现。代码块可返回一个值或者什么都不反回，这里的代码块块等同于方法的方法体。如果是表达式，也可以返回一个值或者什么都不反回。
// 1. 不需要参数,返回值为 2
() -> 2
// 2. 接收一个参数(数字类型),返回其2倍的值
x -> 2 * x
// 3. 接受2个参数(数字),并返回他们的和
(x, y) -> x + y
// 4. 接收2个int型整数,返回他们的乘积
(int x, int y) -> x * y
// 5. 接受一个 string 对象,并在控制台打印,不返回任何值(看起来像是返回void)
(String s) -> System.out.print(s)

🍎1.2 函数式接口🍎

要了解Lambda表达式,首先需要了解什么是函数式接口，函数式接口定义：一个接口有且只有一个抽象方法 。

注意：

  1. 如果一个接口只有一个抽象方法，那么该接口就是一个函数式接口
  2. 如果我们在某个接口上声明了 @FunctionalInterface 注解，那么编译器就会按照函数式接口的定义来要求该接口，这样如果有两个抽象方法，程序编译就会报错的。所以，从某种意义上来说，只要你保证你的接口中只有一个抽象方法，你可以不加这个注解。加上就会自动进行检测的。

定义方式：

@FunctionalInterface
interface NoParameterNoReturn {
    //注意：只能有一个方法
    void test();
}

但是这种方式也是可以的：

@FunctionalInterface
interface NoParameterNoReturn {
    void test();
    default void test2() {
        System.out.println("JDK1.8新特性，default默认方法可以有具体的实现");
    }
}

🏀2 Lambda表达式的基本使用🏀

首先，我们实现准备好几个接口：

//无返回值无参数
@FunctionalInterface
interface NoParameterNoReturn {
    void test();
}
//无返回值一个参数
@FunctionalInterface
interface OneParameterNoReturn {
    void test(int a);
}
//无返回值多个参数
@FunctionalInterface
interface MoreParameterNoReturn {
    void test(int a,int b);
}
//有返回值无参数
@FunctionalInterface
interface NoParameterReturn {
    int test();
}
//有返回值一个参数
@FunctionalInterface
interface OneParameterReturn {
    int test(int a);
}
//有返回值多参数
@FunctionalInterface
interface MoreParameterReturn {
    int test(int a,int b);
}

我们在上面提到过，Lambda可以理解为：Lambda就是匿名内部类的简化，实际上是创建了一个类，实现了接口，重写了接口的方法 。

没有使用lambda表达式的时候的调用方式 ：

    NoParameterNoReturn noParameterNoReturn = new NoParameterNoReturn(){
        @Override
        public void test() {
            System.out.println("hello");
        }
    };
noParameterNoReturn.test();

具体使用见以下示例代码：

    public class TestDemo {
        public static void main(String[] args) {
            NoParameterNoReturn noParameterNoReturn = ()->{
                System.out.println("无参数无返回值");
            };
            noParameterNoReturn.test();
            OneParameterNoReturn oneParameterNoReturn = (int a)->{
                System.out.println("一个参数无返回值："+ a);
            };
            oneParameterNoReturn.test(10);
            MoreParameterNoReturn moreParameterNoReturn = (int a,int b)->{
                System.out.println("多个参数无返回值："+a+" "+b);
            };
            moreParameterNoReturn.test(20,30);
            NoParameterReturn noParameterReturn = ()->{
                System.out.println("有返回值无参数！");
                return 40;
            };
//接收函数的返回值
            int ret = noParameterReturn.test();
            System.out.println(ret);
            OneParameterReturn oneParameterReturn = (int a)->{
                System.out.println("有返回值有一个参数！");
                return a;
            };
            ret = oneParameterReturn.test(50);
            System.out.println(ret);
            MoreParameterReturn moreParameterReturn = (int a,int b)->{
                System.out.println("有返回值多个参数！");
                return a+b;
            };
            ret = moreParameterReturn.test(60,70);
            System.out.println(ret);
        }
    }

🍈2.1 语法精简🍈

  1. 参数类型可以省略，如果需要省略，每个参数的类型都要省略。
  2. 参数的小括号里面只有一个参数，那么小括号可以省略
  3. 如果方法体当中只有一句代码，那么大括号可以省略
  4. 如果方法体中只有一条语句，且是return语句，那么大括号可以省略，且去掉return关键字。

示例代码：

    public static void main(String[] args) {
        MoreParameterNoReturn moreParameterNoReturn = ( a, b)->{
            System.out.println("无返回值多个参数，省略参数类型："+a+" "+b);
        };
        moreParameterNoReturn.test(20,30);
        OneParameterNoReturn oneParameterNoReturn = a ->{
            System.out.println("无参数一个返回值,小括号可以胜率："+ a);
        };
        oneParameterNoReturn.test(10);
        NoParameterNoReturn noParameterNoReturn = ()->System.out.println("无参数无返回值，方法体中只有一行代码");
        noParameterNoReturn.test();
//方法体中只有一条语句，且是return语句
        NoParameterReturn noParameterReturn = ()-> 40;
        int ret = noParameterReturn.test();
        System.out.println(ret);
    }

🏈3 变量捕获🏈

Lambda 表达式中存在变量捕获 ，了解了变量捕获之后，我们才能更好的理解Lambda 表达式的作用域 。Java当中的匿名类中，会存在变量捕获。

🏆3.1 匿名内部类🏆

匿名内部类就是没有名字的内部类 。我们这里只是为了说明变量捕获，所以，匿名内部类只要会使用就好，那么下面我们来，简单的看看匿名内部类的使用就好了。

具体想详细了解的同学戳这里：https://www.cnblogs.com/SQP51312/p/6100314.html

我们通过简单的代码来学习一下：

class Test {
    public void func(){
        System.out.println("func()");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        new Test(){
            @Override
            public void func() {
                System.out.println("我是内部类，且重写了func这个方法！");
            }
        };
    }
}

在上述代码当中的main函数当中，我们看到的就是一个匿名内部类的简单的使用。

🥇3.2 匿名内部类的变量捕获🥇

class Test {
    public void func(){
        System.out.println("func()");
    }
}
public class TestDemo {
    public static void main(String[] args) {
        int a = 100;
        new Test(){
            @Override
            public void func() {
                System.out.println("我是内部类，且重写了func这个方法！");
                System.out.println("我是捕获到变量 a == "+a
                        +" 我是一个常量，或者是一个没有改变过值的变量！");
            }
        };
    }
}

在上述代码当中的变量a就是，捕获的变量。这个变量要么是被final修饰，如果不是被final修饰的 你要保证在使用之前，没有修改。如下代码就是错误的代码。

public class TestDemo {
    public static void main(String[] args) {
        int a = 100;
        new Test(){
            @Override
            public void func() {
                a = 99;
                System.out.println("我是内部类，且重写了func这个方法！");
                System.out.println("我是捕获到变量 a == "+a
                        +" 我是一个常量，或者是一个没有改变过值的变量！");
            }
        };
    }
}

该代码直接编译报错。

🥈3.3 Lambda的变量捕获🥈

在Lambda当中也可以进行变量的捕获，具体我们看一下代码。

    @FunctionalInterface
    interface NoParameterNoReturn {
        void test();
    }
    public static void main(String[] args) {
        int a = 10;
        NoParameterNoReturn noParameterNoReturn = ()->{
// a = 99; error
            System.out.println("捕获变量："+a);
        };
        noParameterNoReturn.test();
    }

⚾️4 Lambda在集合当中的使用⚾️

为了能够让Lambda和Java的集合类集更好的一起使用，集合当中，也新增了部分接口，以便与Lambda表达式对接。

以上方法的作用可自行查看我们发的帮助手册。我们这里会示例一些方法的使用。注意：Collection的forEach()方法是从接口 java.lang.Iterable 拿过来的。

🏄‍♀️4.1 Collection接口🏄‍♀️

forEach() 方法演示

该方法在接口 Iterable 当中，原型如下：

default void forEach(Consumer<? super T> action) {
    Objects.requireNonNull(action);
    for (T t : this) {
        action.accept(t);
    }
}

该方法表示：对容器中的每个元素执行action指定的动作 。

    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("Hello");
        list.add("bit");
        list.add("hello");
        list.add("lambda");
        list.forEach(new Consumer<String>(){
            @Override
            public void accept(String str){
//简单遍历集合中的元素。
                System.out.print(str+" ");
            }
        });
    }

输出结果：

我们可以修改为如下代码：

    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("Hello");
        list.add("bit");
        list.add("hello");
        list.add("lambda");
//表示调用一个，不带有参数的方法，其执行花括号内的语句，为原来的函数体内容。
        list.forEach(s -> {
            System.out.println(s);
        });
    }

输出结果：

🏊‍♀️4.2 List接口🏊‍♀️

sort()方法的演示

sort方法源码：该方法根据c指定的比较规则对容器元素进行排序。

public void sort(Comparator<? super E> c) {
    final int expectedModCount = modCount;
    Arrays.sort((E[]) elementData, 0, size, c);
    if (modCount != expectedModCount) {
        throw new ConcurrentModificationException();
    }
    modCount++;
}

使用示例：

    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("Hello");
        list.add("bit");
        list.add("hello");
        list.add("lambda");
        list.sort(new Comparator<String>() {
            @Override
            public int compare(String str1, String str2){
//注意这里比较长度
                return str1.length()-str2.length();
            }
        });
        System.out.println(list);
    }

输出结果：

修改为lambda表达式：

    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        list.add("Hello");
        list.add("bit");
        list.add("hello");
        list.add("lambda");
//调用带有2个参数的方法，且返回长度的差值
        list.sort((str1,str2)-> str1.length()-str2.length());
        System.out.println(list);
    }

输出结果：

🤽‍♀️4.3 Map接口🤽‍♀️

HashMap 的 forEach()

该方法原型如下：

    default void forEach(BiConsumer<? super K, ? super V> action) {
        Objects.requireNonNull(action);
        for (Map.Entry<K, V> entry : entrySet()) {
            K k;
            V v;
            try {
                k = entry.getKey();
                v = entry.getValue();
            } catch(IllegalStateException ise) {
// this usually means the entry is no longer in the map.
                throw new ConcurrentModificationException(ise);
            }
            action.accept(k, v);
        }
    }

作用是对Map中的每个映射执行action指定的操作。

代码示例：

public static void main(String[] args) {
    HashMap<Integer, String> map = new HashMap<>();
    map.put(1, "hello");
    map.put(2, "bit");
    map.put(3, "hello");
    map.put(4, "lambda");
    map.forEach(new BiConsumer<Integer, String>(){
        @Override
        public void accept(Integer k, String v){
            System.out.println(k + "=" + v);
        }
    });
}

输出结果：

使用lambda表达式后的代码：

public static void main(String[] args) {
    HashMap<Integer, String> map = new HashMap<>();
    map.put(1, "hello");
    map.put(2, "bit");
    map.put(3, "hello");
    map.put(4, "lambda");
    map.forEach((k,v)-> System.out.println(k + "=" + v));
}

输出结果：

🥎5 总结🥎

Lambda表达式的优点很明显，在代码层次上来说，使代码变得非常的简洁。缺点也很明显，代码不易读。

优点：

  1. 代码简洁，开发迅速
  2. 方便函数式编程
  3. 非常容易进行并行计算
  4. Java 引入 Lambda，改善了集合操作

缺点：

  1. 代码可读性变差
  2. 在非并行计算中，很多计算未必有传统的 for 性能要高
  3. 不容易进行调试

感谢各位读者的阅读，本文章有任何错误都可以在评论区发表你们的意见，我会对文章进行改正的。如果本文章对你有帮助请动一动你们敏捷的小手点一点赞，你的每一次鼓励都是作者创作的动力哦！😘

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/552218.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

Linux Audio (7) DAPM-4 Path/Route添加过程

Linux Audio (7) DAPM-4 Path/Route添加过程

DAPM-4 Path/Route添加过程 route分类&#xff1a;route转化为Pathcodec驱动add widgetMechine驱动add kcontrol route分类&#xff1a; 常规route {“sink”, NULL, “source”}&#xff0c;其path->connect1 sink widget是Mixer {“Mixer”, name1, “source1”} {“Mixe…
阅读更多...
chatgpt赋能Python-python88

chatgpt赋能Python-python88

Python88 简介 Python88 是一个优秀的 Python 开源库&#xff0c;它提供了许多有用的函数和工具&#xff0c;可用于创建高效的 Web 应用程序&#xff0c;简化数据分析、数据可视化以及机器学习和人工智能任务等。 Python88 帮助开发人员以更简单、更快捷的方式编写代码&#…
阅读更多...
VS Code Remote Development

VS Code Remote Development

1、Ubuntu 上启用 SSH &#xff08;1&#xff09;打开终端&#xff0c;并且安装openssh-server软件包&#xff1a; sudo apt update sudo apt install openssh-server 当被提示时&#xff0c;输入你的密码并且按 Enter&#xff0c;继续安装。 &#xff08;2&#xff09;安…
阅读更多...
RocketMQ消息发送

RocketMQ消息发送

消息发送示例代码&#xff1a; public static void main(String[] args) throws MQClientException, InterruptedException {DefaultMQProducer producer new DefaultMQProducer("please_rename_unique_group_name");producer.setNamesrvAddr("127.0.0.1:9876…
阅读更多...
leetcode-743. 网络延迟时间

leetcode-743. 网络延迟时间

1.思路分析&#xff1a; 一道Dijkstra模板题 推荐Dijkstra算法讲解教程 Dijkstra&#xff08;有向图某点到其他所有点的最短路径问题&#xff09; Dijkstra算法的基本思想是贪心策略&#xff0c;每次从未确定最短路径的顶点中选择距离源点最近的一个&#xff0c;然后以该顶点…
阅读更多...
Python使用正则表达式

Python使用正则表达式

正则表达式&#xff08;Regular Expression&#xff09;&#xff0c;又称规则表达式&#xff0c;是一个计算机科学的概念&#xff0c;通常被用来检索和替换符合某些规则的文本。 1. 正则表达式语法 正则表达式就是记录文本规则的代码。 1. 行定位符 行定位符就是用来描述字…
阅读更多...
【STM32G431RBTx】备战蓝桥杯嵌入式→决赛试题→第十二届

【STM32G431RBTx】备战蓝桥杯嵌入式→决赛试题→第十二届

文章目录 前言一、题目二、模块初始化三、代码实现interrupt.h:interrupt.c:main.h:main.c: 四、完成效果五、总结 前言 无 一、题目 二、模块初始化 1.LCD这里不用配置&#xff0c;直接使用提供的资源包就行 2.ADC:开启ADCsingle-ended 3.LED:开启PC8-15,PD2输出模式就行了…
阅读更多...
MySQL高级（InnoDB引擎）

MySQL高级（InnoDB引擎）

&#xff08;一&#xff09;逻辑存储结构 表空间&#xff08;ibd文件&#xff09;&#xff0c;会生成ibd文件&#xff0c;一个mysql实例可以对应多个表空间&#xff0c;用于存储记录、索引等数据。 段&#xff0c;分为数据段&#xff08;Leaf node segment&#xff09;、索引段…
阅读更多...
学弟研一，有几篇SCI论文，做过前端，读博 or 走开发进国企？

学弟研一，有几篇SCI论文，做过前端，读博 or 走开发进国企？

同学你好&#xff0c;在正面先抛开选择就业的方面的问题&#xff0c;其实我觉得生活种的很多选择&#xff0c;都可以从以下的几点进行斟酌与考虑&#xff1a; &#xff08;1&#xff09;你最擅长的是哪个方面&#xff1f;&#xff08;2&#xff09;你的兴趣爱好是在哪个方面&am…
阅读更多...
从0开始搭建完整UVM工程（可直接用于实际的工程中）、含源码(包括makefile文件)、可直接运行，及详细注释

从0开始搭建完整UVM工程（可直接用于实际的工程中）、含源码(包括makefile文件)、可直接运行，及详细注释

一、说明 网上的实现uvm工程代码都是抄自张强所著的《UVM实战》，都是讲所有文件放到一个文件夹，且不涉及到实际工程中的uvm结构，以及多文件层级结构，让人理解起来较为困难，本文则将会从0开始教大家如何搭建一个具有实际工程效果的UVM框架： 其对应的书中的框架图如下所示：…
阅读更多...
chatgpt赋能Python-pythoncontinue

chatgpt赋能Python-pythoncontinue

简介 Python是一种高级编程语言&#xff0c;受到越来越多的人们的欢迎。其中&#xff0c;continue是Python语言中的一个很重要的关键字&#xff0c;它的出现可以很好地帮助程序员们实现自己的编程目标。在本文中&#xff0c;我们将介绍continue关键字&#xff0c;并解释它在Py…
阅读更多...
Fourier分析入门——第5章——连续函数

Fourier分析入门——第5章——连续函数

目录 第 5 章 连续函数 5.1 引言 5.2 内积和正交性(Inner products and orthogonality) 5.3 对称性(Symmetry) 5.4 复数值函数 第 5 章 连续函数 5.1 引言 在前面的章节中&#xff0c;我们只考虑了在有限区间 L 上定义的离散函数的Fourier级数模型。此类函数在实验科学…
阅读更多...
spring 源码

spring 源码

bean的创建 获取类class 推断构造方法 Autoware 创建一个普通对象 依赖注入 populateBean 把一些属性注入 初始化之前 PostConstruct 注解 初始注入 实际可以用构造方法啊 初始化 initializationBean 1.判断是否有aware接口 invokeAwareMethods 2.执行 applyBeanP…
阅读更多...
enq: TM - contention等待事件引起的数据库卡顿分析

enq: TM - contention等待事件引起的数据库卡顿分析

用户的数据库系统在2022年5月31日下午17:25至17:45出现严重的锁等待&#xff0c;导致对应的应用程序出现卡顿等情况&#xff0c;业务系统的正常使用受到影响&#xff0c;无法正常办理业务&#xff1b;在此情况下需要排查出锁问题的深层原因&#xff0c;从而从根本上解决问题。 …
阅读更多...
【Python psycopg2】零基础也能轻松掌握的学习路线与参考资料

【Python psycopg2】零基础也能轻松掌握的学习路线与参考资料

Python psycopg2是一个Python库&#xff0c;在Python中提供了一个连接PostgreSQL数据库的接口。它可以让Python应用程序和PostgreSQL数据库之间进行通信和数据传输。学习Python psycopg2的路线和教程可以在查阅资料和实践中快速入门。 一、学习前置知识 学习Python psycopg2需…
阅读更多...
23 memset 的调试

23 memset 的调试

前言 同样是一个 很常用的 glibc 库函数 不管是 用户业务代码 还是 很多类库的代码, 基本上都会用到 内存数据的设置 不过 我们这里是从 具体的实现 来看一下 它的实现 主要是使用 汇编 来进行实现的, 因此 理解需要一定的基础 测试用例 就是简单的使用了一下 memcpy,…
阅读更多...
去面试测试开发工程师要做哪些准备？大厂真实面试题汇总

去面试测试开发工程师要做哪些准备？大厂真实面试题汇总

目录 1.黑盒测试和白盒测试的区别特点和方法。 2.单元测试、集成测试、系统测试、验收测试、回归测试 3.集成测试和系统测试的区别和应用场景 4.α测试、β测试&#xff0c;以及它们的区别 5.给你一个字符串&#xff0c;你怎么判断是不是ip地址&#xff1f;手写这段代码&…
阅读更多...
大数据之RDD的算子分类

大数据之RDD的算子分类

文章目录 前言一、RDD的算子分类二、Transformation转换算子三、Action动作算子总结 前言 #博学谷IT学习技术支持# 上一篇文章主要讲述了两种RDD的创建方式&#xff0c;本篇文章接着讲RDD的算子及其分类。 一、RDD的算子分类 RDD的算子主要有两种类型&#xff0c;一种是Tran…
阅读更多...
docker面试题：docker容器虚拟化与传统虚拟机比较

docker面试题：docker容器虚拟化与传统虚拟机比较

容器就是将软件打包成标准化单元&#xff0c;以用于开发、交付和部署。 容器镜像是轻量的、可执行的独立软件包 &#xff0c;包含软件运行所需的所有内容&#xff1a;代码、运行时环境、系统工具、系统库和设置。容器化软件在任何环境中都能够始终如一地运行。容器赋予了软件独…
阅读更多...
什么是强化学习？强化学习有哪些框架、算法、应用？

什么是强化学习？强化学习有哪些框架、算法、应用？

什么是强化学习&#xff1f; 强化学习是人工智能领域中的一种学习方式&#xff0c;其核心思想是通过一系列的试错过程&#xff0c;让智能体逐步学习如何在一个复杂的环境中进行最优的决策。这种学习方式的特点在于&#xff0c;智能体需要通过与环境的交互来获取奖励信号&#…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023