Lambda表达式

最新推荐文章于 2022-01-12 14:23:48 发布
最新推荐文章于 2022-01-12 14:23:48 发布
阅读量193 收藏
点赞数
分类专栏： Java Lambda 文章标签： java lambda
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_53529114/article/details/114264587
版权
Java 同时被 2 个专栏收录
36 篇文章 1 订阅
订阅专栏
Lambda
1 篇文章 0 订阅
订阅专栏

Lambda表达式

1.函数式编程思想

1.1 概述

在数学中，函数就是有输入量、输出量的一套计算方案，也就是“拿数据做操作”

面向对象思想强调“必须通过对象的形式做事情”

函数式思想则尽量忽略面向对象的复杂语法：“强调做什么，而不是以什么方式去做”

我们要学习的Lambda表达式就是函数式思想的体现

2.体验Lambda表达式

2.1 案例

需求：启动一个线程，控制台输出一句话：多线程程序启动了

2.2 实现方式

方式1：

  1. 定义一个类MyRunnable实现Runnable接口，重写run()方法
  2. 创建MyRunnable类的对象
  3. 创建Thread类对象，把MyRunnable对象作为构造方法参数传递
  4. 启动线程

方式2：

  1. 匿名内部类的方式改进

方式3：

  1. Lambda表达式的方式改进
package com.advanced.lambda;

public class LambdaDemo {
    public static void main(String[] args) {
        //方式1：实现类的方式实现需求
//        MyRunnable my = new MyRunnable();
//        Thread t = new Thread(my);
//        t.start();

        //方式2：匿名内部类方式改进
//        new Thread(new Runnable(){
//            @Override
//            public void run() {
//                System.out.println("多线程程序启动了");
//            }
//        }).start();

        //方式3：Lambda表达式方式改进
        new Thread( () -> {
            System.out.println("多线程程序启动了");
        } ).start();
    }
}

class MyRunnable implements Runnable{
    @Override
    public void run() {
        System.out.println("多线程程序启动了");
    }
}

3.Lambda表达式标准格式

3.1 匿名内部类代码分析

匿名内部类中重写run()方法的代码分析：

​ new Thread(new Runnable(){
​ @Override
​ public void run() {
​ System.out.println(“多线程程序启动了”);
​ }
​ }).start();

  1. 方法形式参数为空，说明调用方法时不需要传递参数
  2. 方法的返回值类型为void，说明方法执行没有结果返回
  3. 方法体中内容，是我们具体要做的事情

3.2Lambda表达式代码分析

Lambda表达式代码分析：

    new Thread( () -> {
    	System.out.println("多线程程序启动了");
    } ).start();
  1. ()：里面没有内容，可以看成是方法形式参数为空
  2. ->：用箭头指向后面要做的事情
  3. {}：包含一段代码，我们称之为代码块，可以看成是方法体中的内容

组成Lambda表达式的三要素：形式参数、箭头、代码块

3.3 格式

Lambda表达式的格式：

  1. 格式：(形式参数) -> {代码块}
  2. 形式参数：如果有多个参数，用逗号隔开；如果没有参数，留空即可
  3. ->：由英文中划线与大于符号组成，固定写法。代表指向操作
  4. 代码块：是我们具体要做的事情，也就是我们以前写的方法体内容

4.Lambda表达式练习

4.1使用条件

Lambda表达式使用条件：

  1. 有一个接口
  2. 接口中有且仅有一个抽象方法

4.2 练习1

练习1：

  1. 定义一个接口(Eatable)，里面定义一个抽象方法void eat();
  2. 定义一个测试类(EatableDemo)，在测试类中提供两个方法
    1. 一个方法是：useEatable(Eatable e)
    2. 一个是主方法，在主方法中调用useEatable()方法

Eatable接口：

public interface Eatable {
    void eat();
}

EetableImpl实现类：

public class EetableImpl implements Eatable{
    @Override
    public void eat() {
        System.out.println("实现类：吃完了");
    }
}

EatableDemo测试类：

public class EatableDemo {
    public static void main(String[] args) {
        //实现类
        EetableImpl e = new EetableImpl();
        useEatable(e);

        //匿名内部类
        useEatable(new Eatable() {
            @Override
            public void eat() {
                System.out.println("匿名内部类：吃完了");
            }
        });

        //Lambda表达式
        useEatable( () -> {
            System.out.println("Lambda表达式：吃完了");
        });
    }

    private static void useEatable(Eatable e){
        e.eat();
    }
}

4.3练习2

练习2：

  1. 定义一个接口(Flyable)，里面定义一个抽象方法void fly(String s);
  2. 定义一个测试类(FlyableDemo)，在测试类中提供两个方法
    1. 一个方法是：useFlyable(Flyable f)
    2. 一个是主方法，在主方法中调用useFlyable()方法

Flyable接口：

public interface Flyable {
    void fly(String s);
}

FlyableImpl实现类：

public class FlyableImpl implements Flyable {
    @Override
    public void fly(String s) {
        System.out.println(s + "飞起来了");
    }
}

FlyableDemo测试类：

public class FlyableDemo {
    public static void main(String[] args) {
        //实现类
        Flyable f = new FlyableImpl();
        useFlyable(f);

        //匿名内部类
        useFlyable(new Flyable() {
            @Override
            public void fly(String s) {
                System.out.println(s + "又飞起来了");
            }
        });

        //Lambda表达式
        useFlyable((String s) -> {
            System.out.println(s + "也飞起来了");
        });
    }

    private static void useFlyable(Flyable f) {
        f.fly("小狗");
    }
}

4.4练习3

练习3：

  1. 定义一个接口(Addable)，里面定义一个抽象方法int add(int x,int y);
  2. 定义一个测试类(AddableDemo)，在测试类中提供两个方法
    1. 一个方法是：useAddable(Addable a)
    2. 一个是主方法，在主方法中调用useAddable()方法

Addable接口：

public interface Addable {
    int add(int x, int y);
}

AddableDemo测试类：

public class AddableDemo {
    public static void main(String[] args) {
        //匿名内部类
        useAddable(new Addable() {
            @Override
            public int add(int x, int y) {
                return x + y;
            }
        });

        //Lambda表达式
        useAddable((int x, int y) -> {
            return x + y;
        });
    }

    private static void useAddable(Addable a) {
        int sum = a.add(10, 20);
        System.out.println(sum);
    }
}

5.Lambda表达式省略模式

5.1 省略规则

省略规则：

  1. 参数类型可以省略，但有多个参数时，需全部省略
  2. 如果参数有且仅有一个，那么小括号可以省略
  3. 如果代码块语句只有一条，可以省略大括号和分号，如果有return，则必须省略return
package com.advanced.lambda.demo04;

import com.advanced.lambda.demo02.Flyable;
import com.advanced.lambda.demo03.Addable;

public class LambdaDemo {
    public static void main(String[] args) {
//        useAddable((int x, int y) -> {
//            return x + y;
//        });
        //参数类型可以省略
        useAddable((x, y) -> {
            return x + y;
        });
        //但有多个参数时，需全部省略
//        useAddable((int x, y) -> {
//            return x + y;
//        });

//        useFlyable((String s) -> {
//            System.out.println(s);
//        });
//        useFlyable((s) -> {
//            System.out.println(s);
//        });
        //如果参数有且仅有一个，那么小括号可以省略
//        useFlyable(s -> {
//            System.out.println(s);
//        });
        //如果代码块语句只有一条，那么可以省略大括号和分号
        useFlyable(s -> System.out.println(s));

        //如果代码块语句只有一条，那么可以省略大括号和分号，如果有return，则必须省略return
        useAddable((x, y) ->  x + y);
    }

    private static void useFlyable(Flyable f){
        f.fly("风和日丽，晴空万里");
    }

    private static void useAddable(Addable a){
        int sum = a.add(10, 20);
        System.out.println(sum);
    }
}

6.Lambda表达式注意事项

6.1注意事项

注意事项：

  1. 使用Lambda必须要有接口，并且要求接口中有且仅有一个抽象方法
  2. 必须有上下文环境，才能推导出Lambda对应的接口
    1. 根据局部变量的赋值得到Lambda对应接口：Runnable r = () -> System.out.println(“Lambda表达式”);
    2. 根据调用方法的参数得到Lambda对应接口：new Thread(() -> System.out.println(“Lambda表达式”)).start();
public class LambdaDemo {
    public static void main(String[] args) {
//        useInter(() -> {
//            System.out.println("好好学习，天天向上");
//        });

        //使用Lambda必须要有接口，并且要求接口中有且仅有一个抽象方法
        useInter(() -> System.out.println("好好学习，天天向上"));

        //必须有上下文环境，才能推导出Lambda对应的接口
//        new Thread(new Runnable() {
//            @Override
//            public void run() {
//                System.out.println("匿名内部类");
//            }
//        }).start();

        Runnable r = () -> System.out.println("Lambda表达式");
        new Thread(r).start();

        new Thread(() -> System.out.println("Lambda表达式")).start();
    }
    private static void useInter(Inter inter){
        inter.show();
    }
}

7.Lambda表达式与匿名内部类的区别

7.1所属类型不同

所属类型不同：

  1. 匿名内部类：可以是接口，抽象类，具体类
  2. Lambda表达式：只能是接口

7.2使用限制不同

使用限制不同：

  1. 如果接口中有且仅有一个抽象方法，可以使用Lambda表达式，也可以使用匿名内部类
  2. 如果接口中多于一个抽象方法，只能使用匿名内部类，而不能使用Lambda表达式

7.3实现原理不同

实现原理不同：

  1. 匿名内部类：编译之后，产生一个单独的class字节码文件
  2. Lambda表达式：编译之后，没有单独的class字节码文件。对应的字节码会在运行的时候动态生成
package com.advanced.lambda.demo06;

import com.advanced.lambda.demo05.Inter;

public class LambdaDemo {
    public static void main(String[] args) {
        //1.区别一
        //匿名内部类：可以是接口，抽象类，具体类；Lambda表达式：只能是接口
        //匿名内部类
        /*
        useInter(new Inter() {
            @Override
            public void show() {
                System.out.println("接口");
            }
        });
        useAnimal(new Animal() {
            @Override
            void eat() {
                System.out.println("抽象类");
            }
        });
        useStudetn(new Student() {
            @Override
            void study() {
                System.out.println("具体类");
            }
        });
         */

        //Lambda
//        useInter(() -> System.out.println("接口"));
//        //useAnimal(() -> System.out.println("抽象类"));
//        //useStudetn(() -> System.out.println("具体类"));

        //2.区别二
        //如果接口中有且仅有一个抽象方法，可以使用Lambda表达式，也可以使用匿名内部类
        //如果接口中多于一个抽象方法，只能使用匿名内部类，而不能使用Lambda表达式
        //Multiple non-overriding abstract methods found in interface com.advanced.lambda.demo05.Inter
        //useInter(() -> System.out.println("接口"));//表明接口存在多个抽象方法

//        useInter(new Inter() {
//            @Override
//            public void show() {
//                System.out.println("show");
//            }
//
//            @Override
//            public void test() {
//                System.out.println("test");
//            }
//        });

        //3.区别三
        //匿名内部类：编译之后，产生一个单独的class字节码文件
        //Lambda表达式：编译之后，没有单独的class字节码文件。对应的字节码会在运行的时候动态生成
//        useInter(new Inter() {
//            @Override
//            public void show() {
//                System.out.println("接口");
//            }
//        });
        useInter(() -> System.out.println("接口"));

    }
    private static void useInter(Inter inter){
        inter.show();
    }
    private static void useAnimal(Animal animal){
        animal.eat();
    }
    private static void useStudetn(Student student){
        student.study();
    }
}

Lambda表达式提示：Multiple non-overriding abstract methods found in interface com.advanced.lambda.demo05.Inter

表明接口存在多个抽象方法

qq_53529114
关注
专栏目录
三：Lambda表达式
qq_39022311的博客
03-17 1489
本章内容 Lambda管中窥豹 在哪里以及如何使用Lambda 环绕执行模式 函数式接口，类型推断 方法引用 Lambda复合 1. lambda管中窥豹 1.1 可以把Lambda表达式理解为简洁地表示可传递的匿名函数的一种方式：它没有名称，但它 有参数列表、函数主体、返回类型，可能还有一个可以抛出的异常列表。这个定义够大的，让我 们慢慢道来。 匿名——我们说匿名，是因为它不像普通的方法...
Java8新特性（二） 之 函数式接口
归心亭
05-07 1234
函数式接口 如果你的好奇心使你翻看Runnable接口源代码，你会发现该接口被一个@FunctionalInterface的注解修饰，这是Java 8中添加的新注解，用于表示 函数式接口。 函数式接口又是什么鬼？ 在Java 8中，把那些仅有一个抽象方法的接口称为函数式接口。如果一个接口被@FunctionalInterface注解标注，表示这个接口被设计成函数式接口，只能有一个抽象方法，如果...
Java8 -- Lambda表达式
Java小皮孩
01-22 3071
Java8 – Lambda表达式介绍 Lambda表达式，也可以称为闭包。Lambda允许把函数作为一个方法的参数传递进方法中使用。 Lambda表达式的使用前提是：接口中只能有一个方法，否则编译报错 Multiple non-overriding abstract methods found in interface：在接口中找到多个非重写的抽象方法 完整的Lambda表达式由三部分组成：1. 参数列表 ； 2. 箭头(->) ； 3. 声明语句 (+ 返回语句) (Type param1, Ty
java8新特性
学无止境！
06-11 422
1、lambda表达式 1.1、用法举例： public class LambdaTest { public static void main(String[] args) { Hello h = ()->10; Hello1 h1 = (a,b) -> a+b; System.out.println(h.sayA()); System.out.println(h1.sayB(3,4)); } } in
Java 8 函数式接口
梦否
04-01 328
在Java 8中新增了很多特性，如： Lambda 表达式； 方法引用； 接口默认实现方法； Stream API，把函数式编程风格引入到Java中； Date Time API，加强了对日期与时间的处理； Optional类，解决空指针异常； 提供了一个新的支持javascript的引擎； 这里，主要记录函数式接口。函数式接口关键字为@FunctionalInterface，是一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口。可以被转换为lambda表达式。 1. lambda表达式 语法结构
Java8新特性Lambda表达式的一些复杂用法总结
08-29
Java 8引入了Lambda表达式，这是一种强大的新特性，它为Java编程语言带来了函数式编程的概念。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表达式是函数式编程的核心元素，它允许我们将函数作为方法参数传递，或者将代码块当作数据...
Lambda表达式里面修改外部变量问题
08-19
Lambda 表达式里面修改外部变量问题 Lambda 表达式是一种匿名函数，可以捕获外部变量，但是它有一个限制：只能捕获 final 或 effectively final 的变量。这意味着，如果我们想在 Lambda 表达式里面修改外部变量的值...
JAVA 8 接口中的默认方法和Lambda 表达式基本使用
coderWang
08-05 699
一、接口中的默认方法 在JDK1.8之前，interface之中可以定义变量和方法，变量必须是public、static、final的，方法必须是public、abstract的 在JDK 1.8开始 支持使用static和default 修饰 可以写方法体，不需要子类重写。 1.1、定义接口默认方法 public interface MyInterface { // 普通抽象方法，默认是public abstract修饰的，没有方法体 void add(); /*
每个 Java 开发者都应该知道的 5 个注解
abc_1114的博客
03-25 298
自 JDK5 推出以来，注解已成为Java生态系统不可缺少的一部分。虽然开发者为Java框架（例如Spring的@Autowired）开发了无数的自定义注解，但编译器认可的一些注解非常重要。 在本文中，我们将看到5个Java编译器支持的注解，并了解其期望用途。顺便，我们将探索其创建背后的基本原理，围绕其用途的一些特质，以及正确应用的一些例子。虽然其中有些注解比其他注解更为常见，但非初学...
Java8揭秘(二)Java 8中的 Lambda表达式
热门推荐
Larry Wang的专栏
04-21 3万+
第一章：Java 8中的 Lambda表达式 在这一章，我们说一说Lambda表达式的语法。我们将从经典的Java语法过渡到新式的Lambda表达式语法。 我们也会讲一讲Lambda表达式的原理-即在运行时Lambda表达式如何表示，另外涉及哪些字节码指令。 入门 如果你熟悉Groovy或者Ruby这些支持Lambda表达式的编程语言，那么你一开始可能会认为Java的Lambda表达式并不
Java 8 新特性：Lambda 表达式
Promise Sun special column
04-11 8718
Lambda 表达式 一.为什么Java 需要Lambda 表达式？ 二.函数式接口 三.Lambda表达式 四.函数式通用接口的出现 …………
Java中实现接口的三种方式您造吗？
liwenxiang629的博客
01-12 6709
本文介绍了Java中实现接口的三种方式：常规实现方式、匿名内部类和 Lambda表达式实现方式。希望已经了解的同学可以重新温习一下，不了解的同学则从中受益！ Java中接口最常规的实现方式 同学们都会知道，java中实现接口的方法通常如下： 定义接口 定义类实现接口 类中重写接口里的方法 创建类对象 调用重写后的方法 代码实现如下： //定义一个接口 public interface ITest { public void func1(); } //类实现该...
java Lambda表达式心得
淡定的人的博客
08-29 2467
java Lambda表达式只能用来简化仅包含一个public方法的接口的创建 括号形式 只能是接口 否则报：Target type of a lambda conversion must be an interface 只能有一个public方法 否则报：Multiple non-overriding abstract methods found AInterface testA((i...
Java_ Java8 的 lambda 表达式
迎难而上
08-07 548
博主之前一直没有搞懂过 lambda 表达式 具体的写法。      但这个语法特性在多种语言中都得到了支持，有必要准备一下，下面附上心得。 参考文章： http://blog.oneapm.com/apm-tech/226.html    （） 在 Java 里将普通的方法或函数像参数一样传值并不简单，为此，Java 8 增加了一个语言级的新特性，名为 Lambda
Jdk8 新特性一： 行为参数+Lambda表達式
qq_34354442的博客
09-28 210
Jdk8 新特性一： 行为参数 2014年3月发布的Java 8，有可能是Java版本更新中变化最大的一次。新的Java 8为开发者带来了许多重量级的新特性，包括Lambda表达式，流式数据处理，新的Optional类，新的日期和时间API等。这些新特性给Java开发者带来了福音，特别是Lambda表达式的支持，使程序设计更加简化。本篇文章将讨论行为参数化，Lambda表达式，函数式接口等特性，今...
Java8实战学习笔记（二）——Java8基础知识
xinyu112的博客
03-26 1322
一、通过行为参数化传递代码（一）、引言在软件工程中，应用的需求不断变化，怎么办？解决方案：行为参数化 —— 意味着：拿出一个代码块，把它准备好却不去执行它。这个代码块以后可以被你程序的其他部分调用，这意味着你可以推迟这块代码的执行。例如，将代码块作为参数传递给另一个方法，稍后再去执行它。eg：行为参数化类似于：处理一个集合，会写以下方法： 可以对列表中的每个元素做“某件事” 可以在列表处理完后...
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、付费专栏及课程。

余额充值