Lambda表达式详解，Optional类的使用

2024-05-25 13:36
文章标签 使用 详解 表达式 lambda optional

本文主要是介绍Lambda表达式详解，Optional类的使用，希望对大家解决编程问题提供一定的参考价值，需要的开发者们随着小编来一起学习吧！

文章目录

  • 前言
  • 序言
  • Lambda 表达式
    • 简介(重要)
    • 基础知识
    • 详解
      • 例一：
      • 例二：
    • lambda的变量捕获
    • 方法引用
      • 静态方法引用
      • 实例方法引用
      • 泛型中的方法引用
      • 构造函数引用
  • 预定义函数接口
  • Optional类的使用

前言

大家对lambda表达式都不陌生，也都使用过lambda表达式，但是这篇文章并不是交你简单的使用，而是更深入的区理解lambda表达式。此外还会了解Optional类的使用对空指针异常的避免

序言

lambda表达式及其相关特是 JDK8 中增加的特性，显著增强了Java，原因有两点：首先 ，添加了新的语法元素，是Java语言的表达能力得以提升，并简化了一些常用结构的实现方式。 其次 ，lambda表达式的加入也导致 API 库中添加了一些新的功能，使程序员能更容易地 利用多核环境的并行处理功能 (尤其是在处理 for-each 风格的操作时)，并且能使用支持对数据执行管道操作的新的流API 。 lambda表达式的引入也催生了其他新的Java功能，包括 默认方法 和 方法引用。

Lambda 表达式

简介(重要)

理解lambda表达式有两个结构非常重要：lambda表达式自身 ， 函数式接口。

  • lambda表达式自身：本质上是一个匿名方法(更确切的说应该是函数式接口的实现类)。这个匿名方法不是独立执行的。而是用于实现函数式接口定义的另一个方法(很像方法重写)。因此，lambda表达式会导致一个匿名内类的生成(所以我会说 lambda应该是函数式接口的实现类)。lambda表达式也常被称为闭包(closure)

关于闭包的解释有很多，大概意思就是：隐式的使用了另一个地方的资源，导致其不能被垃圾回收，占用空间资源。

  • 函数式接口：仅包含一个抽象方法的接口。大家对函数式接口都不陌生，但是 JDK8 以后的接口 和以前的接口 以有所不同。前言中我提到了 默认方法 ，默认方法是在接口中定义的方法，使用 default 修饰且可以包含方法体(这与原始接口的方法定义有很大的区别)，其实现类可重写可不重写，可直接调用。
    以 Consumer接口为例：
    @FunctionalInterface
public interface Consumer<T> {void accept(T t);default Consumer<T> andThen(Consumer<? super T> after) {Objects.requireNonNull(after);return (T t) -> { accept(t); after.accept(t); };}
}
    可以看出在 Consumer接口中 包含一个 默认方法和一个抽象方法，但仍被称为函数式接口
    所以，一个接口中无论包含多少个方法，只要 只有一个 抽象方法，该接口就可被称为函数式接口

基础知识

->：lambda操作符 或 箭头操作符
左侧：指定了lambda表达式的所有参数(没有则为空)
右侧：指定了lambda体，即lambda表达式所要执行的动作

Java定义了两种lambda体：一种包含单个表达式，另一种包含一个代码块

单个表达式：( ) -> xxx 如，() -> 123.4 单个表达式即为返回值
代码块：( ) -> { }

详解

例一：

上述我说 lambda是函数式接口实现类，为什么这样说呢？看下面的例子

interface MyInterface {void get();
}@Test
public void Text() {//父类引用指向子类对象MyInterface my = () -> {System.out.println("你好Lambda");};my.get();  //输出：你好Lambda
}//MyInterface my = () -> {System.out.println("你好Lambda");};
//这种方式的书写是不是很熟悉，等价如下：
@Test
public void Text() {MyInterface my = new MyInterface {  //父类引用指向子类对象@Overridevoid get(){System.out.println("你好Lambda");}}my.get();  //输出：你好Lambda
}

所以：lambda表达式就是函数式接口的实现类，其书写形式( () -> {} )就是在重写接口中的方法
而且前面也说过，lambda表达式会导致一个匿名类的生成，该匿名类就是接口实现类。这个结论很重要，在接下来的讨论中我会多次用到这个结论

例二：

用上述结论与大家讨论一下我们用的最多的 for-each 循环。
forEach 是 Iterable接口中的一个默认方法，Iterable接口包含三个方法，但是一个函数式接口，只包含一个 Iterator() 抽象方法。forEach方法描述如下

default voidforEach(Consumer<? super T> action)

大家可能都写过这样的forEach

    @Testpublic void demo1(){ArrayList<Object> objects = new ArrayList<>();objects.add("a");objects.add("b");objects.add("c");objects.add("d");objects.forEach(item -> {System.out.println(item); //打印集合中的元素});}

那么，forEach内部是如何进行的，换句话说，为什么一条lambda表达式就可以进行打印操作。我们自己就可进行一个简单的实现：

public class ForEachDemo<E> implements Iterable<E>{private int size = 0;  //数组中元素的个数E[] array;public ArrayStack() {array = (E[]) new Object[10];  }//我们自己进行forEach的简单实现@Overridepublic void forEach(Consumer<? super E> action) {for (int i = 0; i < size; i++) {action.accept(array[i]); //调用抽象方法，将数组元素传入}}//添加元素，最多为10public boolean add(E value) {if (isFull()) {return false;}array[size++] = value;return true;}public boolean isFull() {return size == array.length;}//Iterable 为函数式接口，必须实现该方法，这里不是重点@Overridepublic Iterator<E> iterator() {return new Iterator<E>() {@Overridepublic boolean hasNext() {return false;}@Overridepublic E next() {return null;}};}
}

测试一下：

@RunWith(JUnit4.class)
public class Test1 {@Testpublic void demo2(){ForEachDemo<String> array = new ForEachDemo<>();array.add("a");array.add("b");array.add("c");array.add("d");array.forEach(item -> {System.out.println(item);});}
}

解释代码：
在重写forEach里面简单的用了一个for循环，并调用了Comsumer接口的accept()方法，在测试类中实现了简单的遍历，前面说过lambda是函数式接口的实现类，测试类中的lambda表达式就是在重写Consumer接口中的accept()方法(accept() 包含一个参数无返回值)，在执行时调用了这个方法，而这个方法就是打印数组元素。看下面对比，更加清晰。

/自定义
public void forEach(Consumer<? super E> action) {for (int i = 0; i < size; i++) {action.accept(array[i]); //调用抽象方法，将数组元素传入}
}
//方法调用
array.forEach(item -> {System.out.println(item);
}); 
//匿名内部类实现
array.forEach(new Consumer<String>() {@Overridepublic void accept(String item) {System.out.println(item);}
});

可以看出，lambda表达式就是 new了一个Consumer接口的实现类，只不过这个过程是隐式的，并重写了accept()方法

我们的结论正不正确，来看一下 ArrayList类中的forEach源码：

@Override
public void forEach(Consumer<? super E> action) {Objects.requireNonNull(action);  		 //判空//modCount相当于一个计数器，再增加或删除操作中会加一或减一。//在AbstractList抽象类中定义final int expectedModCount = modCount;final Object[] es = elementData;  //elementDate保存元素的数组final int size = this.size;		  //元素个数//这里就是为什么在forEach中不能做增加或删除操作/**lambda重写accept()方法，在其中执行增加或删除操作会使modCount != expectedModCount  */for (int i = 0; modCount == expectedModCount && i < size; i++)//重点：同样调用了Consumer接口的accept()方法//执行lambda表达式action.accept(elementAt(es, i));   if (modCount != expectedModCount)throw new ConcurrentModificationException();
}

可以发现，我们定义的forEach与源码是很相似的，同样使用了普通for，并调用了accept()方法。
至此：我们论证了我们的结论。
注意：虽然lambda是函数式接口的实现类，但lambda并没有自己的this参数，这与匿名内部类不同。在lambda中调用this实则使调用其外层类的this参数。

接下来带大家看一下lambda一些有趣的地方。

lambda的变量捕获

lambda：可以调用表达式外部类的实例 或 静态变量以及 final的局部变量。
而调用 final的局部变量 时会形成变量捕获 ------ 就是，如果lambda内部要想访问外部类中的局部变量，那该变量必须是 final 的，不能修改。

访问静态变量：

public class Test{static int a = 10;public static void main(String[] args) {ArrayList<String> array = new ArrayList<>();array.add("a");array.add("b");array.add("c");array.add("d");array.forEach(item -> {a = 100;System.out.print(item);System.out.println(a);});}
}//a100//b100//c100//d100

访问 final的局部变量

public class Test{public static void main(String[] args) {ArrayList<String> array = new ArrayList<>();array.add("a");array.add("b");array.add("c");array.add("d");int a = 10;array.forEach(item -> {int b = a + 90;System.out.print(item);System.out.println(b);});}
}//a100//b100//c100//d100

a实质上是final变量，素以可以在，lambda内部使用，但如在内部修改了a的值，不管是lambda内部还是外部，a都会丢失实质上的final状态，会报错，无法通过编译 ---- 即lambda内部不能修改局部变量。
但是真的不能修改吗？ 是可以的，只不过性质发生了改变，该值不再是 final变量，而是variable易变的，只需要使用 java.util.concurrent 并发工具包中的 atomic 子包中的类即可。如下：

public class Test {public static void main(String[] args) {ArrayList<String> array = new ArrayList<>();array.add("a");array.add("b");array.add("c");array.add("d");AtomicInteger a = new AtomicInteger(10);array.forEach(item -> {a.set(100);System.out.print(item);System.out.println(a);});}
}//a100//b100//c100//d100

总：lambda可以访问外部变量(很水的总结)

后面的其实我不想说了，该聊的其实都聊的差不多了，后面的就是lambda的另一种写法，你肯定写过，如: System.out::ptintln(item);,预定义接口呢？你也见过，Consumer我们已将聊过了。
map()都用过吧，该方法需要的函数式接口参数就是：Function<T,R>;后面的有时间再写吧。

方法引用

静态方法引用

实例方法引用

泛型中的方法引用

构造函数引用

预定义函数接口

Optional类的使用

这篇关于Lambda表达式详解，Optional类的使用的文章就介绍到这儿，希望我们推荐的文章对编程师们有所帮助！


http://www.chinasem.cn/article/1001650。

相关文章

Spring Security 基于表达式的权限控制

Spring Security 基于表达式的权限控制

前言 spring security 3.0已经可以使用spring el表达式来控制授权，允许在表达式中使用复杂的布尔逻辑来控制访问的权限。 常见的表达式 Spring Security可用表达式对象的基类是SecurityExpressionRoot。 表达式描述hasRole([role])用户拥有制定的角色时返回true （Spring security默认会带有ROLE_前缀）,去
阅读更多...
Spring Security基于数据库验证流程详解

Spring Security基于数据库验证流程详解

Spring Security 校验流程图 相关解释说明（认真看哦） AbstractAuthenticationProcessingFilter 抽象类 /*** 调用 #requiresAuthentication(HttpServletRequest, HttpServletResponse) 决定是否需要进行验证操作。* 如果需要验证，则会调用 #attemptAuthentica
阅读更多...
中文分词jieba库的使用与实景应用（一）

中文分词jieba库的使用与实景应用（一）

知识星球：https://articles.zsxq.com/id_fxvgc803qmr2.html 目录 一.定义： 精确模式（默认模式）： 全模式： 搜索引擎模式： paddle 模式（基于深度学习的分词模式）： 二 自定义词典 三.文本解析   调整词出现的频率 四. 关键词提取 A. 基于TF-IDF算法的关键词提取 B. 基于TextRank算法的关键词提取
阅读更多...
使用SecondaryNameNode恢复NameNode的数据

使用SecondaryNameNode恢复NameNode的数据

1）需求： NameNode进程挂了并且存储的数据也丢失了，如何恢复NameNode 此种方式恢复的数据可能存在小部分数据的丢失。 2）故障模拟 （1）kill -9 NameNode进程 [lytfly@hadoop102 current]$ kill -9 19886 （2）删除NameNode存储的数据（/opt/module/hadoop-3.1.4/data/tmp/dfs/na
阅读更多...
Hadoop数据压缩使用介绍

Hadoop数据压缩使用介绍

一、压缩原则 （1）运算密集型的Job，少用压缩 （2）IO密集型的Job，多用压缩 二、压缩算法比较 三、压缩位置选择 四、压缩参数配置 1）为了支持多种压缩/解压缩算法，Hadoop引入了编码/解码器 2）要在Hadoop中启用压缩，可以配置如下参数
阅读更多...
Makefile简明使用教程

Makefile简明使用教程

文章目录 规则makefile文件的基本语法：加在命令前的特殊符号：.PHONY伪目标: Makefilev1 直观写法v2 加上中间过程v3 伪目标v4 变量 make 选项-f-n-C Make 是一种流行的构建工具，常用于将源代码转换成可执行文件或者其他形式的输出文件(如库文件、文档等)。Make 可以自动化地执行编译、链接等一系列操作。 规则 makefile文件
阅读更多...
使用opencv优化图片（画面变清晰）

使用opencv优化图片（画面变清晰）

文章目录 需求影响照片清晰度的因素 实现降噪测试代码 锐化空间锐化Unsharp Masking频率域锐化对比测试 对比度增强常用算法对比测试 需求 对图像进行优化，使其看起来更清晰，同时保持尺寸不变，通常涉及到图像处理技术如锐化、降噪、对比度增强等 影响照片清晰度的因素 影响照片清晰度的因素有很多，主要可以从以下几个方面来分析 1. 拍摄设备 相机传感器：相机传
阅读更多...
OpenHarmony鸿蒙开发（ Beta5.0）无感配网详解

OpenHarmony鸿蒙开发（ Beta5.0）无感配网详解

1、简介 无感配网是指在设备联网过程中无需输入热点相关账号信息，即可快速实现设备配网，是一种兼顾高效性、可靠性和安全性的配网方式。 2、配网原理 2.1 通信原理 手机和智能设备之间的信息传递，利用特有的NAN协议实现。利用手机和智能设备之间的WiFi 感知订阅、发布能力，实现了数字管家应用和设备之间的发现。在完成设备间的认证和响应后，即可发送相关配网数据。同时还支持与常规Sof
阅读更多...
C++11第三弹：lambda表达式 | 新的类功能 | 模板的可变参数

C++11第三弹：lambda表达式 | 新的类功能 | 模板的可变参数

🌈个人主页： 南桥几晴秋 🌈C++专栏： 南桥谈C++ 🌈C语言专栏： C语言学习系列 🌈Linux学习专栏： 南桥谈Linux 🌈数据结构学习专栏： 数据结构杂谈 🌈数据库学习专栏： 南桥谈MySQL 🌈Qt学习专栏： 南桥谈Qt 🌈菜鸡代码练习： 练习随想记录 🌈git学习： 南桥谈Git 🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈🌈�
阅读更多...
06 C++Lambda表达式

06 C++Lambda表达式

lambda表达式的定义 没有显式模版形参的lambda表达式 [捕获] 前属性 (形参列表) 说明符 异常 后属性 尾随类型 约束 {函数体} 有显式模版形参的lambda表达式 [捕获] <模版形参> 模版约束 前属性 (形参列表) 说明符 异常 后属性 尾随类型 约束 {函数体} 含义 捕获：包含零个或者多个捕获符的逗号分隔列表 模板形参：用于泛型lambda提供个模板形参的名
阅读更多...

Copyright China编程 23002807@qq.com

沪ICP备2023033072号-2