Java，Lambda表达式、方法引用和构造器引用

已于 2023-11-30 19:32:20 修改
阅读量971 收藏 28
点赞数 25
分类专栏： Java，从入门到入土 文章标签： java
于 2023-11-30 19:30:21 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2302_79468488/article/details/134719623
版权

目录

一、Lambda表达式

语法格式：

格式一：无参数，无返回值。

格式二：要参数，无返回值。

格式三：数据类型可以省略，可以由编译器进行类型推断。

格式四：只有一个参数时，参数的小括号可以省略。

格式五：有两个及以上的参数，有多条执行语句，并且有返回值。

格式六：当l方法体只有一条语句时，大括号{}可以省略。如果只有一条return语句，则大括号{}和return一并省略。

函数式接口（FunctionalInterface）

四个基本的函数式接口：

Lambda表达式的总结：

二、方法引用

具体使用情况：

情况1：对象 :: 实例方法

情况2：类 :: 类方法（静态方法）

情况3：类 :: 实例方法

三、构造器引用：

四、数组引用：

一、Lambda表达式

Lambda是一个匿名函数，可以把Lambda表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）。使用其可以写出更灵活、简洁的代码。
Lambda表达式用于简写用接口的引用创建对象的操作（ 需满足此接口中只有一个抽象方法，即此接口为函数式接口）。
Lambda表达式的使用的举例：
(o1,o2) -> Integer . compare (o1,o2);
Lambda表达式的格式：
-> ：lambda操作符或箭头操作符
->左边的内容：lambda形参列表（对应着要重写的接口中的抽象方法中的形参列表）
->右边的内容：lambda体（对应着接口的实现类要重写的方法的方法体）
格式：lambda形参列表 -> lambda体 

语法格式：

格式一：无参数，无返回值。

以Runnable接口为例： 
Runnable r1 = new Runnable()
{
    @Override
    public void run()
    {
        System.out.println("I love China");
    }
};

等同于：

Runnable r2 = () -> {
    System.out.println("I love China");
};

格式二：要参数，无返回值。

以Consumer接口为例：

Consumer<String> con1 = new Consumer<String>()
{
    @Override
    public void accept(String s)
    {
        System.out.println(s);
    }
};

等同于：

Consumer<String> con2 = (String s) -> {
    System.out.println(s);
};

格式三：数据类型可以省略，可以由编译器进行类型推断。

还是以Consumer接口为例：

Consumer<String> con1 = new Consumer<String>()
{
    @Override
    public void accept(String s)
    {
        System.out.println(s);
    }
};

等同于：

Consumer<String> con2 = (s) -> {
    System.out.println(s);
};

格式四：只有一个参数时，参数的小括号可以省略。

还是以Consumer接口为例：

Consumer<String> con1 = new Consumer<String>()
{
    @Override
    public void accept(String s)
    {
        System.out.println(s);
    }
};

等同于：

Consumer<String> con2 = s -> {
    System.out.println(s);
};

格式五：有两个及以上的参数，有多条执行语句，并且有返回值。

以Comparator接口为例：

Comparator<Integer> com1 = new Comparator<Integer>()
{
    @Override
    public int compare(Integer o1, Integer o2)
    {
        System.out.println(o1);
        System.out.println(o2);
        return Integer.compare(o1,o2);
    }
};

等同于：

Comparator<Integer> com2 = (o1,o2) -> {
    System.out.println(o1);
    System.out.println(o2);
    return Integer.compare(o1,o2);
};

格式六：当l方法体只有一条语句时，大括号{}可以省略。如果只有一条return语句，则大括号{}和return一并省略。

还是以Comparator接口为例：

Comparator<Integer> com1 = new Comparator<Integer>()
{
    @Override
    public int compare(Integer o1, Integer o2)
    {
        return Integer.compare(o1,o2);
    }
};

等同于：

Comparator<Integer> com2 = (o1,o2) -> Integer.compare(o1,o2);

Lambda表达式的本质：一方面，Lambda表达式作为接口的实现类的对象。另一方面，Lambda表达式是一个匿名方法。

函数式接口（FunctionalInterface）

如果接口中只有一个抽象方法，则此接口就称为函数式接口。

只有给函数式接口提供实现类的对象时，我们才可以使用Lambda表达式。

API中函数式接口所在的包：java.util.function

四个基本的函数式接口：

函数式接口

称谓

参数类型

用途

Consumer<T>

消费型接口

T

对类型为T的对象应用操作，包含方法:void accept(T t)

Supplier<T>

供给型接口

无

返回类型为T的对象，包含方法：T get()

Function<T,R>

函数型接口

T

对类型为T的对象应用操作，并返回结果。结果是R类型的对象。包含方法：R apply(Tt)

Predicate<T>

判断型接口

T

确定类型为T的对象是否满足某约束，并返回boolean值。包含方法：boolean test(T t)

Lambda表达式的总结：

->的左边：lambda形参列表，参数的类型都可以省略。如果形参只有一个，则括号( )也可以省略。

->的右边：lambda体，对应着重写的方法体。当方法体只有一条语句时，大括号{}可以省略。如果只有一条return语句，则大括号{}和return一并省略。

二、方法引用

使用举例：

以Comparable接口为例：

Comparator<Integer> com1 = new Comparator<Integer>()
{
    @Override
    public int compare(Integer o1, Integer o2)
    {
        return Integer.compare(o1,o2);
    }
};

等同于：

Comparator<Integer> com3 = Integer :: compare;

方法引用可以看作是基于lambda表达式的进一步刻画。当需要提供一个函数式接口的实例时，可以使用Lambda表达式。当满足一定条件的情况下，我们还可以使用方法引用或构造器引用替换lambda表达式。

方法引用作为了函数式接口的实例。

格式：类（或对象）:: 方法名

具体使用情况：

情况1：对象 :: 实例方法

函数式接口中的抽象方法A，其匿名内部类的匿名对象的实现方法中，调用了某个对象O的某个方法B（非静态）的形参列表与返回值类型与抽象方法A的形参列表与返回值类型一致（可以满足自动装箱和自动拆箱，或满足多态性），可以用方法B对方法A替换、覆盖，便可以直接表示为 对象（对象O） :: 实例方法（方法B）。此替换覆盖即为方法引用。

以Consumer接口为例：（注：System.out是一个对象）

//匿名内部类的格式
Consumer<String> con1 = new Consumer<String>()
{
    @Override
    public void accept(String s)
    {
        System.out.println(s);
    }
};
//Lambda表达式的格式
Consumer<String> con2 = s -> System.out.println(s);
//方法引用的格式
Consumer<String> con3 = System.out::println;

以Supplier接口为例：

Person pp = new Person(12,"Tom");
//匿名内部类的格式
Supplier<String> sup1 = new Supplier<String>()
{
    @Override
    public String get()
    {
        return pp.getName();
    }
};
//Lambda表达式的格式
Supplier<String> sup2 = () -> pp.getName();
//方法引用的格式
Supplier<String> sup3 = pp :: getName;

情况2：类 :: 类方法（静态方法）

函数式接口中的抽象方法A，其匿名内部类的匿名对象的实现方法中，调用了某个类C的某个类方法B（静态方法）的形参列表与返回值类型与抽象方法A的形参列表与返回值类型一致（可以满足自动装箱和自动拆箱，或满足多态性），可以用方法B对方法A替换、覆盖，便可以直接表示为 类（类C） :: 实例方法（方法B）。

以Comparable接口为例：

//匿名内部类的格式
Comparator<Integer> com1 = new Comparator<Integer>()
{
    @Override
    public int compare(Integer o1, Integer o2)
    {
        return Integer.compare(o1,o2);
    }
};
//Lambda表达式的格式
Comparator<Integer> com2 = (o1, o2) -> Integer.compare(o1,o2);
//方法引用的格式
Comparator<Integer> com3 = Integer :: compare;

以Function接口为例：

//匿名内部类的格式
Function<Double,Long> fun1 = new Function<Double, Long>()
{
    @Override
    public Long apply(Double aDouble)
    {
        return Math.round(aDouble);
    }
};
//Lambda表达式的格式
Function<Double,Long> fun2 = aDouble -> Math.round(aDouble);
//方法引用的格式
Function<Double,Long> fun3 = Math :: round;

情况3：类 :: 实例方法

函数式接口中的抽象方法A，其匿名内部类的匿名对象的实现方法中，调用了某个对象O的某个方法B（非静态）的返回值类型与抽象方法A的返回值类型一致（可以满足自动装箱和自动拆箱，或满足多态性）。

同时，方法A中有n个参数，方法B中有n-1个参数，且抽象方法A的第一个参数作为方法B的调用者（即对象O），方法B的n-1个参数与方法A的第一个参数之后的n-1个参数一致（可以满足自动装箱和自动拆箱，或满足多态性），可以用方法B对方法A替换、覆盖，便可以直接表示为 类（对象O所在的类） :: 实例方法（方法B）。此替换覆盖即为方法引用。

比如，若A方法的参数依次为H、I、J、K类型的，B方法的参数依次应该为I、J、K类型的（或满足自动装箱和自动拆箱，或满足多态性）。

以Comparator接口为例：

//匿名内部类的格式
Comparator<String> com1 = new Comparator<String>()
{
    @Override
    public int compare(String s1, String s2)
    {
        return s1.compareTo(s2);
    }
};
//Lambda表达式的格式
Comparator<String> com2 = (s1,s2) -> s1.compareTo(s2);
//方法引用
Comparator<String> com3 = String :: compareTo;

以BiPredicate接口为例：

//匿名内部类的格式
BiPredicate<String,String> biPre1 = new BiPredicate<String, String>()
{
    @Override
    public boolean test(String s1, String s2)
    {
        return s1.equals(s2);
    }
};
//Lambda表达式的格式
BiPredicate<String,String> biPre2 = (s1,s2) -> s1.equals(s2);
//方法引用
BiPredicate<String,String> biPre3 = String :: equals;

三、构造器引用：

格式：类名 :: new

以Suppiler为例：

//匿名内部类的格式
Supplier<Person> sup1 = new Supplier<Person>()
{
    @Override
    public Person get()
    {
        return new Person();
    }
};
System.out.println(sup1.get());
//Lambda表达式的格式
Supplier<Person> sup2 = () -> new Person();
//构造器引用的格式
Supplier<Person> sup3 = Person :: new;

说明：

·调用了类名对应的类中的某一个确定的构造器

·具体调用的是与函数式接口中的抽象方法的形参列表一致（可以满足自动装箱和自动拆箱，或满足多态性）的形参列表的构造器。

以Function接口和BiFunction接口为例：

//匿名内部类的格式
Function<Integer,Person> func1 = new Function<Integer, Person>()
{
    @Override
    public Person apply(Integer integer)
    {
        return new Person(integer);
    }
};
//Lambda表达式的格式
Function<Integer,Person> func2 = integer -> new Person(integer);
//构造器引用
Function<Integer,Person> func3 = Person :: new;//调用的是参数为Integer类型的，由于自动拆箱，调用的是int类型的构造器


//匿名内部类的格式
BiFunction<Integer,String,Person> biF1 = new BiFunction<Integer, String, Person>()
{
    @Override
    public Person apply(Integer integer, String s)
    {
        return new Person(integer,s);
    }
};
//Lambda表达式的格式
BiFunction<Integer,String,Person> biF2 = (integer,s) -> new Person(integer,s);
//构造器引用的格式
BiFunction<Integer,String,Person> biF3 = Person :: new;

四、数组引用：

格式：数组名[ ] :: new

说明：数组引用里的数组的长度由方法的参数决定。

例：

//匿名内部类的格式
Function<Integer,Person[]> fu1 = new Function<Integer, Person[]>()
{
    @Override
    public Person[] apply(Integer integer)
    {
        return new Person[integer];
    }
};
//Lambda表达式的格式
Function<Integer,Person[]> fu2 = integer -> new Person[integer];
//构造器引用的格式
Function<Integer,Person[]> fu3 = Person[] :: new;

二狗mao
关注
  • 25
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
Java基础理论之Lambda表达式，方法引用
Allen_Heng的博客
09-27 541
函数式编程思想，让编码偏向于过程，让我们书写代码是关注关键所在而不在于固定形式。 函数式编程思想概述 在数学中，函数就是有输入量、输出量的一套计算方案，也就是“拿什么东西做什么事情”。相对而言，面向对象过分强调“必须通过对象的形式来做事情”，而函数式思想则尽量忽略面向对象的复杂语法——强调做什么，而不是以什么形式做。 做什么，而不是怎么做 传递一段代码——这才是我们真正的目的。而创建对象只是受限于面向对象语法而不得不采取的一种手段方式。那，有没有更加简单的办法？如果我们将关注点从“怎么做”回归到“做
lanlan2017#JavaReadingNotes#6.8.3 方法引用与构造器引用1
07-25
- 第6章 面向对象(下)6.8.3 方法引用与构造器引用如果Lambda表达式的代码块只有一条代码,程序就可以省略Lambda表达式中代码块的花括号。如果L
Java Lambda表达式的方法引用和构造器引用实例分析
08-25
主要介绍了Java Lambda表达式的方法引用和构造器引用,结合实例形式分析了Lambda表达式的方法引用和构造器引用相关原理、用法及操作注意事项,需要的朋友可以参考下
lambda表达式方法引用和构造器引用
qq_33732195的博客
03-01 383
方法引用 若lambda体中的功能，已经有方法提供了实现，可以使用方法引用；可以将方法引用理解为 lambda 表达式的另外一种表现形式； 对象的引用 :: 实例方法名 public void test1(){ //Comparator 消费型接口 Consumer<String> con = (str) -> System.out.println(str); ...
springBean结合lambda function
yin__ren的博客
03-20 103
【代码】springBean结合lambda function。
Java Lambda表达式和方法引用
冰茶不冰的博客
03-01 1135
Lambda表达式是JDK1.8开始之后的新技术，是一种代码的新语法，其核心目的是为了简化匿名内部类的代码写法。
java引用和lambda_Java Lambda表达式的方法引用和构造器引用实例分析
weixin_29322855的博客
02-25 117
本文实例讲述了Java Lambda表达式的方法引用和构造器引用。分享给大家供大家参考，具体如下：一 点睛如果Lambda表达式的代码块只有一条代码，还可以在代码块中使用方法引用和构造器引用，以使得Lambda表达式更加简洁。种类示例说明对应的Lambda表达式引用类方法类名::类方法函数式接口中被实现方法的全部参数传给该类方法作为参数。(a,b,...) -> 类名.类方法(a,b, .....
Java Lambda表达式之方法引用与构造器引用
qq_40373914的博客
04-22 186
方法引用与构造器引用 1. 概念 如果lambda体中的内容已经有方法实现了，可以使用方法引用代替整个lambda表达式。 2. 方法引用的语法格式 第一种：对象::方法名 代码示例： public class Employee { private String id; private String name; private Integer age; priv...
Java：Lambda表达式、方法引用
游手好闲
01-06 841
Java：Lambda表达式、方法引用
java_lambda表达式中的方法引用
beginnerdzz的博客
06-03 941
我们在使用lambda时，如果方法体中只有一个方法的调用的话（包括构造方法）,我们可以用方法引用进一步简化代码。也是一个语法糖 了解 知道是什么意思 可以读懂其他人的代码即可 写多了 也就熟练了 可以使用快捷键先生成 面向快捷键开发​ 类名或者对象名::方法名 使用前提 ​ 如果我们在重写方法的时候，方法体中只有一行代码，并且这行代码是调用了某个类的静态方法，并且我们把要重写的抽象方法中所有的参数都按照顺序传入了这个静态方法中，这个时候我们就可以引用类的静态方法。例如：如下代码就可以用方法引用进行简化 注
Java - Lambda表达式 / 方法引用 / 构造器引用 / 数组引用（多种情况举例说明）
H_X_P_的博客
03-23 926
Java - Lambda表达式 / 方法引用 / 构造器引用 / 数组引用（多种情况举例说明）
Java8 新特性之lamdba表达式和Optional
03-19
1.3 方法引用和构造器 12 1.2.1 方法引用 12 1.2.2 构造器 12 1.4 Stream语法 13 1.3.1 入门案例 13 1.3.2 怎么得到Stream 15 1.3.3 转换Stream 16 1.3.4 汇聚Stream 19 2 Optional类 20 2.1 创建Optional容器 21 ...
Java面向对象系列[Lambda]
12-22
Lambda表达式支持将代码块作为方法参数，Lambda表达式允许使用更简洁的代码来创建只有一个抽象方法的接口（这种接口叫函数式接口）的实例 public class ProcessArray { public void process(int[] target, Command ...
JVM调用Lambda的表达式实现方法原理详解.docx
07-03
invokespecial：用于调用实例构造器方法、私有方法和父类中的方法。 invokevirtual：用于调用所有的虚方法。 invokeinterface：用于调用接口方法，会在运行时再确定一个实现该接口的对象。 invokedynamic：...
进阶2 探索图形化编程：扩展图形组件与切片开发的魅力
优树搭的博客
05-30 1497
当这些切片成功地通过图形程序串联起来后，在后续进行程序升级或维护时，大家会惊喜地发现，图形程序就如同清晰的路标一般，可以非常便捷地通过图形程序准确地定位到相关切片，并对这些切片进行在线查看、编辑和执行等操作。而且，这些切片的代码长度通常不会太长，相比传统开发的代码，阅读起来要容易得多，这无疑会给系统后续的工作带来极大的便利。
JAVAEE之多线程进阶（2）_ CAS概念、实现原理、ABA问题及解决方案
2301_80653026的博客
05-29 1531
CAS全称Compare and swap，字面意思:”比较并交换“，它是一条 CPU 并发原语，用于判断内存中某个值是否为预期值，如果是则更改为新的值，这个过程是原子的。全称 Compare and swap, 即 “比较并交换”. 相当于通过一个原子的操作, 同时完成 “读取内存, 比较是否相等, 修改内存” 这三个步骤. 本质上需要 CPU 指令的支撑。
operator ＜=＞ (spaceship operator)
janeqi1987的专栏
05-28 1062
= 与!= 操作符为了检查是否相等，现在定义== 操作符就够了。当编译器找不到表达式的匹配声明a!=b 时，编译器会重写表达式并查找!(a==b)。若这不起作用，编译器也会尝试改变操作数的顺序，所以也会尝试!(b==a):a!=b,!(b==a)因此，对于TypeA 的a 和TypeB 的b，编译器将能够识别并编译a!= b若需要的话，可以这样做• 一个独立函数operator!• 一个独立函数operator==(TypeA, TypeB)
Java 异常处理中try-catch块、finally子句以及自定义异常的使用
最新发布
Itmastergo的博客
05-31 898
异常是程序运行过程中出现的非正常情况。Java 使用异常类（Exception 类及其子类）来表示这些异常情况。异常处理的核心思想是将正常的程序流程与异常处理流程分离开来，使代码更加清晰和可维护。Throwable 类：所有异常和错误的基类。Error 类：表示系统级的错误，程序通常无法处理，比如内存不足（OutOfMemoryError）。Exception 类：表示程序中可以处理的异常情况。RuntimeException 类。
lambda表达式 条件构造器
09-06
- *2* *3* [java8新特性之lambda表达式(及方法引用与构造器引用)](https://blog.csdn.net/cristianoxm/article/details/110222407)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

二狗mao

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值