Lambda表达式

最新推荐文章于 2024-08-13 19:45:55 发布
最新推荐文章于 2024-08-13 19:45:55 发布
阅读量67 收藏
点赞数
分类专栏： Java学习笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zxl2029/article/details/117456718
版权

Lambda表达式

  • 概述
    Lambda表达式可以看做一个可以重写函数式接口抽象方法的实现类对象。

  • 使用前提

    • .必须是接口，并且接口中有且仅有一个抽象方法。（函数式接口）
    • .有上下文环境，才能推导出Lambda对应的接口"实现类对象"。
      1. 根据局部变量的赋值推导Lambda对应的接口：Runnable r = () -> System.out.println(“Lambda表达式”);
      2. 根据调用方法的参数推导Lambda对应的接口：new Thread(() -> System.out.println(“Lambda表达式”)).start();

  • Lambda的标准格式

    • 格式：(形式参数) -> {代码块}
      • 形式参数：根据函数式接口抽象方法的参数而定，有多个参数用逗号隔开；没有参数就留空
      • ->：固定写法，代表指向动作。
      • 代码块：具体要做的事情，类似匿名内部类方法体内容。（抽象方法的方法体具体实现）

  • 启动一个线程，用实现Runnable接口、匿名内部类和Lambda表达式进行对比

    class MyRunnable implements Runnable{
    @Override
    public void run() {
        System.out.println("Runnable线程启动了");
    }
}
public class Demo {
    public static void main(String[] args) {
        //实现Runnable接口，启动新线程
        MyRunnable mr = new MyRunnable();
        Thread t1 = new Thread(mr);
        t1.start();
        //匿名内部类，启动新线程
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("匿名内部类线程启动了");
            }
        }).start();
        //Lambda表达式，启动新线程
        new Thread(() -> {
            System.out.println("Lambda线程启动了");
        }).start();
    }
}
---*---
输出结果：
Runnable线程启动了
匿名内部类线程启动了
Lambda线程启动了

    Lambda表达式 ( ) -> { }，和匿名内部类对比可以将：

    • ( )：看作抽象方法形式参数为空
    • ->：箭头指向方法体
    • { }：看作方法体中的内容

练习

  • 函数式接口，无参无返回值抽象方法

    //有且仅有一个抽象方法的接口
interface A{
    void eat();
}

    class B implements A{
    @Override
    public void stude() {
        System.out.println("好好学习，天天向上");
    }
}
public class Demo {
    public static void main(String[] args) {
	    //创建实现类
	    B b = new B();
	    show(b);
	    //匿名内部类
	    show(new A() {
	        @Override
	        public void stude() {
	            System.out.println("好好学习，天天向上");
	        }
	    });
	    //Lambda
	    show(()->{
	        System.out.println("好好学习，天天向上");
	    });
    }
    //参数是A接口的测试方法
    public static void show(A a){
        a.eat();
    }
}
---*---
输出结果：
好好学习，天天向上
好好学习，天天向上
好好学习，天天向上

  • 函数式接口，带参无返回值抽象方法

    //接口，一个带参抽象方法
interface A{
    void stude(String s);
}

    public class Demo {
    public static void main(String[] args) {
	    //匿名内部类
	    show(new A() {
	        @Override
	        public void stude(String s) {
	            System.out.println(s);
	            System.out.println("好好学习，天天向上");
	        }
	    });
	
	    //Lambda
	    show((String s)->{
	        System.out.println(s);
	        System.out.println("好好学习，天天向上");
	    });
    }
    //调用接口的测试方法
    public static void show(A a){
        a.stude("圆圆");
    }
}
---*---
输出结果：
圆圆
好好学习，天天向上
圆圆
好好学习，天天向上

  • 函数式接口，带参有返回值抽象方法

    //函数接口，带参有返回值
interface A{
    int add(int x, int y);
}

    public class Demo {
    public static void main(String[] args) {
        //Lambda
        test((int x, int y) ->{
            return x+y;
        });
    }
    //调用接口的测试方法
    public static void test(A a){
        int add = a.add(10, 20);
        System.out.println(add);
    }
}
---*---
输出结果：
30

Lambda省略模式

  • 概述：

    • 1.参数类型可以省略。如有多个参数只能都省略或都不省略。
    • 2.参数有且仅有一个，圆括号可以省略。
    • 3.如果代码块语句只有一条，可以省略大括号和分号；有返回值还要省略return。

  • ①省略参数类型

    //函数式接口
public interface Inter {
    int est(int x, int y);
}

    public class Demo {
    public static void main(String[] args) {
        //Lambda
        show((int x,int y) -> {
            return x+y;
        });
        //ambda省略参数类型
        show((x,y) -> {
            return x+y;
        });
    }
    public static void show(Inter in){
        int est = in.est(10, 20);
        System.out.println(est);
    }
}
---*---
输出结果：
30
30

    注意：有多个参数的情况下，只能都省略或者都不省略。

  • ②如果只有一个参数，小括号可以省略。

    //函数式接口
public interface Inter {
    void est(int x);
}

    public class Demo {
    public static void main(String[] args) {
        //Lambda
        show((x) ->{
            System.out.println(x);
        });
        //Lambda，省略圆括号
        show(x -> {
            System.out.println(x);
        });
    }
    public static void show(Inter in){
         in.est(100);
    }
}
---*---
输出结果：
100
100

  • ③如果代码块的语句只有一条，可以省略花括号和分号

    //函数式接口
public interface Inter {
    void est(int x);
}

    public class Demo {
    public static void main(String[] args) {
        //Lambda
        show(x ->{
            System.out.println(x);
        });
        //Lambda，省略大括号
        show(x -> System.out.println(x));
    }
    public static void show(Inter in){
         in.est(100);
    }
}
---*---
输出结果：
100
100

    注意：Lambda表达式在只有一条语句，省略调花括号和分号的情况下。如果该抽象方法有返回值，还需要省略 return。

Lambda表达式和匿名内部类的区别

  • 所需类型不同

    • 匿名内部类：可以是接口、抽象类和具体类

    • Lambda表达式：只能是接口

      //函数式接口
public interface S1 {
    void inter();
}
//抽象类
abstract class S2{
    abstract void abs();
}
//具体类
class S3{
    void cla(){}
}

      public class Demo {
    //测试方法，参数为接口，抽象类和具体类对象
    public static void show1(S1 s1){
        s1.inter();
    }
    public static void show2(S2 s2){
        s2.abs();
    }
    public static void show3(S3 S3){
        S3.cla();
    }
    //mian方法
    public static void main(String[] args) {
        //传入匿名内部类对象
        show1(new S1() {
            @Override
            public void inter() {
                System.out.println("inner-s1");
            }
        });
        show2(new S2() {
            @Override
            void abs() {
                System.out.println("inner-s2");
            }
        });
        show3(new S3(){
            @Override
            void cla() {
                System.out.println("inner-s3");
            }
        });

        //传入Lambda表达式推导的实现类对象
        show1(() -> {
            System.out.println("Lambda-s1");
        });
//        show2(() -> {});//报错，Lambda转换的目标类型必须是接口
//        show3(() -> {});//报错，Lambda转换的目标类型必须是接口
    }
}
---*---
输出结果：
inner-s1
inner-s2
inner-s3
Lambda-s1

  • 使用限制不同

    • 接口中有且仅有一个抽象方法，可以使用Lambda表达式或匿名内部类
    • 接口中有多个抽象方法，只能使用匿名内部类。
      //有多个抽象方法的接口
public interface S1 {
    void inter();
    void inter1();
}

      public class Demo {
    //测试方法，参数为接口
    public static void show1(S1 s1){
        s1.inter();
    }
    //main
    public static void main(String[] args) {
        //匿名内部类
        show1(new S1() {
            @Override
            public void inter() {
                System.out.println("inner-s1");
            }
            @Override
            public void inter1() {

            }
        });
        //Lambda
//        show1(() -> {});//报错，存在多个抽象方法
    }
}

  • 实现原理不同

    • 匿名内部类：编译后，产生一个单独的.class字节码文件
    • Lambda表达式：编译后，不产生单独的.class字节码文件。对应的字节码会在运行时动态生成。
zxl2029
关注
专栏目录
ambda表达式
08-09 471
转自：http://biezhi.me/2017/07/17/keep-up-with-java8-lambda.html 从java8出现以来lambda是最重要的特性之一，它可以让我们用简洁流畅的代码完成一个功能。 很长一段时间java被吐槽是冗余和缺乏函数式编程能力的语言，随着函数式编程的流行java8种也引入了 这种编程风格。在此之前我们都在写匿名内部类干这些事，...
Lambda表达式java实现
weixin_44867972的博客
09-04 205
解释都在注释中 基本概念以及用法 package Demo16Lambda; /** * 使用lambda表达式可以对一个接口进行非常简洁的实现 * * 虽然可以使用lambda表达式对某些接口进行简单的实现，但是并不是所有的接口都可以 * 用lambda表达式来实现，要求接口中定义的必须从要实现的抽象方法只能是一个。 * * 在jdk8中接口新加了一个特性，default。 * * @FunctionlIntyerface * 修饰函数式接口，接口中的抽象方法只有一个。 */ pub
Lambda表达式超详细总结
热门推荐
huangjhai的博客
07-07 9万+
在2014年Oracle发布了Java 8,在里面增加了Lambda模块。于是Java程序员们又多了一种新的编程方式：函数式编程。
lambda表达式
最新发布
weixin_67804833的博客
08-13 1170
便于并行处理：Lambda表达式与Java 8引入的Stream API结合使用，可以方便地进行集合的并行处理，充分发挥多核处理器的优势，提高代码的执行效率。可读性的折衷：尽管Lambda表达式可以提高代码的可读性，但在某些复杂的情况下，Lambda表达式可能变得难以理解和阅读，特别是当表达式变得过于复杂时。避免匿名内部类的繁琐语法：相比于使用匿名内部类，Lambda表达式的语法更为简洁，减少了冗余的代码，提高了编码效率。Lambda主体可以是一个表达式，表达式外的大括号，可加可不加。
Lambda表达式详解
唯有努力，方可自信！
06-14 7152
本篇文章将介绍Java中的Lambda表达式，它是Java 8中引入的一项新特性，也是函数式编程的一种风格。我们将深入研究Lambda表达式的语法和用法，讲解如何使用Lambda表达式来写出更加简洁、易读的代码，并介绍Lambda表达式在Java中的应用场景及其优缺点。无论您是初学者还是有一定经验的程序员，本文都将为您提供宝贵的参考和帮助。
C++11：lambda表达式
Man9o
03-09 1万+
通常lambda表达式用于封装一些传递给算法或异步函数的代码。C++11中引入了λ表达式，它可以用来定义一个**内联 (inline)**的函数，作为一个本地的对象或者一个参数。内联函数是一种编译器优化技术，它可以避免函数调用的开销，提高执行效率。λ表达式可以被编译器自动内联展开，从而减少函数调用的次数。但是，并不是所有的λ表达式都会被内联，这取决于编译器的实现和优化策略。
Lambda 表达式
小鲁蛋的博客
08-21 4615
Lambda 是一个匿名函数，我们可以把 Lambda 表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）。使用它可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升。Lambda 表达式：在Java 8 语言中引入的一种新的语法元素和操作符。这个操作符为 “->” ， 该操作符被称为Lambda 操作符或箭头操作符。左边：lambda形参列表 （其实就是接口中的抽象方法的形参列表）
C ++ Lambda表达式详解
白云之道
12-19 5万+
C ++ Lambda表达式详解 1.Lambda表达式概述 ​ Lambda表达式是现代C++在C ++ 11和更高版本中的一个新的语法糖 ，在C++11、C++14、C++17和C++20中Lambda表达的内容还在不断更新。 lambda表达式（也称为lambda函数）是在调用或作为函数参数传递的位置处定义匿名函数对象的便捷方法。通常，lambda用于封装传递给算法或异步方法的几行代码 。本文主要介绍Lambda的工作原理以及使用方法。 2.Lambda表达式定义 2.1 Lambda表达式示例 ​
Java中Lambda表达式使用及详解
qq_45263520的博客
03-27 7万+
Java中Lambda表达式使用及详解 前言 一、Lambda表达式的简介 Lambda表达式（闭包）：java8的新特性，lambda运行将函数作为一个方法的参数，也就是函数作为参数传递到方法中。使用lambda表达式可以让代码更加简洁。 Lambda表达式的使用场景：用以简化接口实现。 关于接⼝实现，可以有很多种⽅式来实现。例如：设计接⼝的实现类、使⽤匿名内部类。 但是lamb
Java8新特性Lambda表达式的一些复杂用法总结
08-29
Java 8引入了Lambda表达式，这是一种强大的新特性，它为Java编程语言带来了函数式编程的概念。Lambda表达式允许程序员创建匿名函数，即没有名称的函数，这些函数可以直接作为值传递给方法或存储在变量中。这使得代码...
Lambda表达式里面修改外部变量问题
08-19
Lambda 表达式里面修改外部变量问题 Lambda 表达式是一种匿名函数，可以捕获外部变量，但是它有一个限制：只能捕获 final 或 effectively final 的变量。这意味着，如果我们想在 Lambda 表达式里面修改外部变量的值...
C#基础之Lambda表达式用法实例教程
09-04
Lambda表达式是C#语言中的一个强大特性，它在C# 3.0及更高版本中引入，使得代码更加简洁、可读性更强。Lambda表达式主要用于创建匿名函数，它可以被赋值给变量，作为参数传递，或者用作方法的返回值。在本教程中，...
C++ 中lambda表达式的编译器实现原理
08-31
C++中的Lambda表达式是C++11引入的一项重要特性，它允许程序员在代码中定义匿名函数，并且可以直接在定义的地方使用。Lambda表达式的引入极大地增强了C++的可读性和简洁性，尤其是在处理函数对象和回调函数时。下面...
Java 8 lambda表达式
06-27
Java 8 的引入，尤其是Lambda表达式，对Java语言产生了深远的影响，它为Java开发者带来了更简洁、更灵活的编程方式。Lambda表达式是函数式编程的核心元素，它允许我们将函数作为方法参数传递，或者将代码块当作数据...
IDEA 中新建 Empty project（空白项目）
zxl2029的博客
02-09 5716
New Project 2.建空白项目 3. 配置环境 4.这里选择新建模块 File–>Now–>Module 下面就可以开始写代码了
面向对象编程思想的理解
zxl2029的博客
04-11 2394
面向对象 什么是面向对象 这里使用面向过程与面向对象对比方式解释什么是面向对象。 一，把想要实现的功能，让一个类实现，而不是具体的实现步骤 二，对象可以是任何事物，比如学生管理系统，的学生可以做成一个类，添加学生的功能可以做成一个类，删除学生功能可以做出一个类，展示学生可以做成一个类等等。 ...
Java程序结构-源文件/类/方法/的关系
zxl2029的博客
04-04 1425
Java源文件 类 属性和方法
类和对象的关系
zxl2029的博客
04-12 457
类和对象的关系 什么是类、什么是对象 类是一个模板，是对对象的抽象。 官方定义 类就是拥有相等功能和相同属性的对象的集合 – 抽象的 对象就是类的实例 – 具体的 生活角度看类和对象 如果人是类，余婷就是对象、骆昊也是对象 如果手机是类，我手中的小米手机就是对象 … 类是拥有相等功能和相同的属性的对象的集合 – 抽象的，可以看成是一类事物的模板。使用事物的属性和行为特征来描述事物。 ...
lambda 表达式
05-28
Lambda 表达式是 C++11 引入的一个新特性，它允许我们在代码中定义匿名函数。Lambda 表达式可以看作是一个可调用的对象，可以像函数一样被调用，但是它不需要像函数一样显式地声明或定义，而是直接在代码中定义。 Lambda 表达式的基本语法如下： ``` [capture list] (params list) mutable exception-> return type { function body } ``` 其中，方括号内的部分是可选的，包含了 lambda 表达式的捕获列表，用于定义 lambda 表达式所需的外部变量。params list 是函数的参数列表，可以为空。mutable 关键字用于控制是否可以修改捕获的变量。exception 是异常说明符，可以为空。return type 是函数的返回类型，可以为空。function body 是函数体。 Lambda 表达式可以作为函数参数传递，可以存储在变量中，也可以作为返回值返回。它可以直接使用当前作用域内的变量，或者通过捕获列表捕获外部变量。Lambda 表达式还支持函数重载、模板参数等高级特性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值