【javaSE】 Lambda表达式与Lambda表达式的使用

news2025/1/19 20:36:02

文章目录

  • 🌳Lambda表达式的背景
    • 🚩Lambda表达式的语法
    • 🚩函数式接口
  • 🎋Lambda表达式的基本使用
    • 🎄语法精简
  • 🌲变量捕获
    • 🚩匿名内部类
    • 🚩匿名内部类的变量捕获
    • 🚩Lambda的变量捕获
  • 🎍Lambda在集合当中的使用
    • 📌Collection接口
    • 📌List接口
    • 📌 Map接口
  • 🌴Lambda表达式总结
  • ⭕总结

🌳Lambda表达式的背景

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

🚩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)

🚩函数式接口

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

注意：

  1. 如果一个接口只有一个抽象方法，那么该接口就是一个函数式接口

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

定义方式：

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

也提供了另一种方式：

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

🎋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);
    }
}

🎄语法精简

  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);
    }

🌲变量捕获

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

🚩匿名内部类

匿名内部类就是没有名字的内部类 。我们这里只是为了说明变量捕获

匿名内部类的简单的使用如下:


/**
 * Created with IntelliJ IDEA.
 * Description:
 * User: GAOBO
 * Date: 2020-04-15
 * Time: 16:16
 */
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这个方法！");
            }
        };
    }
}

🚩匿名内部类的变量捕获

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修饰的 你要保证在使用之前，没有修改

🚩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();
    }

🎍Lambda在集合当中的使用

为了能够让Lambda和Java的集合类集更好的一起使用，集合当中，也新增了部分接口，以便与Lambda表达式对接
在这里插入图片描述

注意：Collection的forEach()方法是从接口 java.lang.Iterable 拿过来的。

📌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("遇事问春风乄");
        list.add("hello");
        list.add("博主");
        list.forEach(new Consumer<String>(){
            @Override
            public void accept(String str){
//简单遍历集合中的元素。
                System.out.print(str+" ");
            }
        });

输出结果：Hello 遇事问春风乄 hello 博主

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

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

输出结果：Hello 遇事问春风乄 hello 博主

📌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("遇事问春风乄");
        list.add("hello");
        list.add("博主");
        list.sort(new Comparator<String>() {
            @Override
            public int compare(String str1, String str2){
//注意这里比较长度
                return str1.length()-str2.length();
            }
        });
        System.out.println(list);
    }

输出结果：遇事问春风乄, Hello, hello, 博主

修改为lambda表达式：

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

输出结果：遇事问春风乄, Hello, hello, 博主

📌 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, "遇事问春风乄");
	map.put(3, "hello");
	map.put(4, "博主");
	map.forEach(new BiConsumer<Integer, String>(){
		@Override
		public void accept(Integer k, String v){
			System.out.println(k + "=" + v);
		}
	});
}

输出结果：

1=hello 2=遇事问春风乄 3=hello 4=博主

使用lambda表达式后的代码：

public static void main(String[] args) {
	HashMap<Integer, String> map = new HashMap<>();
	map.put(1, "hello");
	map.put(2, "遇事问春风乄");
	map.put(3, "hello");
	map.put(4, "博主");
	map.forEach((k,v)-> System.out.println(k + "=" + v));
}

输出结果：

1=hello 2=遇事问春风乄 3=hello 4=博主

🌴Lambda表达式总结

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

优点：

  1. 代码简洁，开发迅速

  2. 方便函数式编程

  3. 非常容易进行并行计算

  4. Java 引入 Lambda，改善了集合操作

缺点：

  1. 代码可读性变差

  2. 在非并行计算中，很多计算未必有传统的 for 性能要高

  3. 不容易进行调试

⭕总结

关于《【javaSE】 Lambda表达式与Lambda表达式的使用》就讲解到这儿，感谢大家的支持，欢迎各位留言交流以及批评指正，如果文章对您有帮助或者觉得作者写的还不错可以点一下关注，点赞，收藏支持一下！

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

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

相关文章

【力扣-二叉树-01】在二叉树中分配硬币-力扣 979 题

【力扣-二叉树-01】在二叉树中分配硬币-力扣 979 题

&#x1f49d;&#x1f49d;&#x1f49d;欢迎来到我的博客&#xff0c;很高兴能够在这里和您见面&#xff01;希望您在这里可以感受到一份轻松愉快的氛围&#xff0c;不仅可以获得有趣的内容和知识&#xff0c;也可以畅所欲言、分享您的想法和见解。 推荐:kuan 的首页,持续学…
阅读更多...
多层全连接网络：实现手写数字识别50轮准确率92.1%

多层全连接网络：实现手写数字识别50轮准确率92.1%

多层全连接网络&#xff1a;实现手写数字识别50轮准确率92.1% 1 导入必备库2 torchvision内置了常用数据集和最常见的模型3 数据批量加载4 绘制样例5 创建模型7 设置是否使用GPU8 设置损失函数和优化器9 定义训练函数10 定义测试函数11 开始训练12 绘制损失曲线并保存13 绘制准…
阅读更多...
C++ std::future

C++ std::future

std::future是用来接收一个线程的执行结果的&#xff0c;并且是一次性的。 共享状态shared state future可以关联一个共享状态&#xff0c;共享状态是用来储存要执行结果的。这个结果是async、promise、packaged_task设置的&#xff0c;且这个结果只能设置一次。 创建future …
阅读更多...
【rtp-benchmarks】读取本地文件基于uvgRtp实现多线程发送

【rtp-benchmarks】读取本地文件基于uvgRtp实现多线程发送

input 文件做内存映射 ： get_mem D:\XTRANS\soup\uvg-rtp-dev\rtp-benchmarks\util\util.cc 文件中读取chunksize 到 vector 里作为chunks 创建多个线程进行发送 std::vector<std::thread*> threads;
阅读更多...
C++数据结构X篇_12_树的基本概念和存储

C++数据结构X篇_12_树的基本概念和存储

学习二叉树之前先学习树的概念。 文章目录 1. 树的基本概念1.1 树的定义1.2 树的特点1.3 若干术语 2. 树的表示法2.1 图形表示法2.2 广义表表示法 3. 树的存储3.1 双亲表示法&#xff1a;保存父节点关系3.2 孩子表示法3.3 左孩子右兄弟表示法 1. 树的基本概念 之前所学均为线性…
阅读更多...
22 相交链表

22 相交链表

相交链表 题解1 快慢双指针改进 (acb bca)题解2 哈希表(偷懒) 给你两个单链表的头节点 headA 和 headB &#xff0c;请你找出并返回两个单链表相交的起始节点。如果两个链表不存在相交节点&#xff0c;返回 null 。 题目数据 保证 整个链式结构中不存在环。 注意&#xff…
阅读更多...
Golang gorm manytomany 多对多 更新、删除、替换

Golang gorm manytomany 多对多 更新、删除、替换

Delete 移除 只删除中间表的数据 删除原有的 var a Article1db.Preload("Tag1s").Take(&a, 1)fmt.Printf("%v", a) {1 k8s [{1 cloud []} {2 linux []}]}mysql> select * from article1; ------------ | id | title | ------------ | 1 | k8s …
阅读更多...
导数公式及求导法则

导数公式及求导法则

目录 基本初等函数的导数公式 求导法则 有理运算法则 复合函数求导法 隐函数求导法 反函数求导法 参数方程求导法 对数求导法 基本初等函数的导数公式 基本初等函数的导数公式包括&#xff1a; C0(x^n)nx^(n-1)(a^x)a^x*lna(e^x)e^x(loga(x))1/(xlna)(lnx)1/x(sinx)cos…
阅读更多...
十大排序算法及Java中的排序算法

十大排序算法及Java中的排序算法

文章目录 一、简介二、时间复杂度三、非线性时间比较类排序冒泡排序&#xff08;Bubble Sort&#xff09;排序过程代码实现步骤拆解演示复杂度 选择排序&#xff08;Selection Sort&#xff09;排序过程代码实现步骤拆解演示复杂度 插入排序&#xff08;Insertion Sort&#xf…
阅读更多...
用冒泡排序完成库函数qsort的作用

用冒泡排序完成库函数qsort的作用

Hello&#xff0c;今天分享的是我们用冒泡函数实现qsort&#xff0c;也就是快排&#xff0c;之前我们也讲过库函数qsort的使用方法&#xff0c;今天我们尝试用冒泡函数实现一下&#xff0c;当然我们也见过qsort&#xff0c;后面也会继续完善的。这几天我是破防大学生&#xff0…
阅读更多...
使用python制作一个简单的任务管理器

使用python制作一个简单的任务管理器

本篇文章教大家 使用 Python 创建一个简单的任务管理器应用程序。这个项目将帮助你练习 Python 编程的许多方面&#xff0c;包括文件操作、用户输入处理和基本的命令行界面设计。在这篇文章中&#xff0c;我将指导你创建一个基本的命令行任务管理器。 目录 任务管理器的用途任务…
阅读更多...
NLP机器翻译全景：从基本原理到技术实战全解析

NLP机器翻译全景：从基本原理到技术实战全解析

目录 一、机器翻译简介1. 什么是机器翻译 (MT)?2. 源语言和目标语言3. 翻译模型4. 上下文的重要性 二、基于规则的机器翻译 (RBMT)1. 规则的制定2. 词典和词汇选择3. 限制与挑战4. PyTorch实现 三、基于统计的机器翻译 (SMT)1. 数据驱动2. 短语对齐3. 评分和选择4. PyTorch实现…
阅读更多...
App Inventor 2 实现Ascii码转换（Ascii编码与解码）

App Inventor 2 实现Ascii码转换（Ascii编码与解码）

之前有同学问&#xff0c;App Inventor 2 字符及Ascii码如何进行转换&#xff0c;经过调查&#xff0c;其原生的组件和内置块无法完成这个功能&#xff0c;网上也有利用Web客户端组件执行js代码来进行转换&#xff0c;不过逻辑稍复杂效率还不高。这里介绍一个拓展可以非常方便的…
阅读更多...
【算法系列 | 8】深入解析查找算法之—二分查找

【算法系列 | 8】深入解析查找算法之—二分查找

序言 心若有阳光&#xff0c;你便会看见这个世界有那么多美好值得期待和向往。 决定开一个算法专栏&#xff0c;希望能帮助大家很好的了解算法。主要深入解析每个算法&#xff0c;从概念到示例。 我们一起努力&#xff0c;成为更好的自己&#xff01; 今天第8讲&#xff0c;讲一…
阅读更多...
CrossOver 23 正式发布：可在 Mac 上运行部分 DX12 游戏

CrossOver 23 正式发布：可在 Mac 上运行部分 DX12 游戏

CodeWeivers 公司于今年 6 月发布了 CrossOver 23 测试版&#xff0c;重点添加了对 DirectX 12 支持&#xff0c;从而在 Mac 上更好地模拟运行 Windows 游戏。 该公司今天发布新闻稿&#xff0c;表示正式发布 CrossOver 23 稳定版&#xff0c;在诸多新增功能中&#xff0c;最值…
阅读更多...
【经典小练习】JavaSE—拷贝文件夹

【经典小练习】JavaSE—拷贝文件夹

&#x1f38a;专栏【Java小练习】 &#x1f354;喜欢的诗句&#xff1a;天行健&#xff0c;君子以自强不息。 &#x1f386;音乐分享【如愿】 &#x1f384;欢迎并且感谢大家指出小吉的问题&#x1f970; 文章目录 &#x1f384;效果&#x1f33a;代码&#x1f6f8;讲解&#x…
阅读更多...
Java学习之--类和对象

Java学习之--类和对象

&#x1f495;粗缯大布裹生涯&#xff0c;腹有诗书气自华&#x1f495; 作者&#xff1a;Mylvzi 文章主要内容&#xff1a;Java学习之--类和对象 类和对象 类的实例化&#xff1a; 1.什么叫做类的实例化 利用类创建一个具体的对象就叫做类的实例化&#xff01; 当我们创建了…
阅读更多...
预算有限但想改善客户服务？教你几招轻松解决~

预算有限但想改善客户服务？教你几招轻松解决~

这里有一个常见的误解&#xff1a;只有大公司需要客户服务。事实是&#xff0c;无论行业规模大小&#xff0c;出色的客户服务对每个企业都至关重要。事实上&#xff0c;企业规模越小&#xff0c;客户服务就越重要&#xff0c;因为他们无法承受失去客户的后果。 不仅如此&#…
阅读更多...
连nil切片和空切片一不一样都不清楚？那BAT面试官只好让你回去等通知了。

连nil切片和空切片一不一样都不清楚？那BAT面试官只好让你回去等通知了。

连nil切片和空切片一不一样都不清楚&#xff1f;那BAT面试官只好让你回去等通知了。 问题 package mainimport ("fmt""reflect""unsafe" )func main() {var s1 []ints2 : make([]int,0)s4 : make([]int,0)fmt.Printf("s1 pointer:%v, s2 p…
阅读更多...
【UE虚幻引擎】UE源码版编译、Andorid配置、打包

【UE虚幻引擎】UE源码版编译、Andorid配置、打包

首先是要下载源码版的UE&#xff0c;我这里下载的是5.2.1 首先要安装Git 在你准备放代码的文件夹下右键点击Git Bash Here 然后可以直接git clone https://github.com/EpicGames/UnrealEngine 不行的话可以直接去官方的Github上下载Zip压缩包后解压 运行里面的Setup.bat&a…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023