Java基础学习笔记25——Lambda表达式

最新推荐文章于 2023-07-17 13:27:04 发布
最新推荐文章于 2023-07-17 13:27:04 发布
阅读量238 收藏
点赞数
分类专栏： JavaSE 文章标签： java 开发语言 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44623055/article/details/122415571
版权

目录

1、Lambda表达式

1.1、函数式编程思想概述

1.2、体验Lambda表达式

1.3、Lambda表达式的标准格式

1.4、Lambda表达式的练习1

1.5、Lambda表达式的练习2

1.6、Lambda表达式的练习3

1.7、Lambda表达式的省略模式

1.8、Lambda表达式的注意事项

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

1、Lambda表达式

1.1、函数式编程思想概述

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

面向对象思想强调“必须通过对象的形式来做事情”；而函数式思想则尽量忽略面向对象的复杂语法，强调做什么，而不是以什么形式去做。

1.2、体验Lambda表达式

代码演示：

package LambdaPackage;

public class RunnableImpl implements Runnable{

    @Override
    public void run() {
        System.out.println("多线程程序启动了。");
    }
}
package LambdaPackage;

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

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

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

1.3、Lambda表达式的标准格式

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

new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("多线程程序启动了。");
            }
        }).start();
  • 方法形式参数为空，说明调用方法时不需要传递参数；
  • 方法返回值类型为void，说明方法执行没有结果返回；
  • 方法体中的内容，是我们具体要做的事情。

Lambda表达式的代码分析：

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

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

Lambda表达式的标准格式：

格式：(形式参数) -> {代码块}

形式参数：如果有多个参数，参数之间用“,”隔开；如果没有参数，留空即可。
->：由英文中画线和大于符号组成，固定写法。代表指向动作。
代码块：是我们具体要做的事情。

Lambda表达式的使用前提：有一个接口，接口中有且仅有一个抽象方法。

1.4、Lambda表达式的练习1

package Lambda2Package;

public interface Eatable {
    void eat();
}
package Lambda2Package;

public class EatableImpl implements Eatable{
    @Override
    public void eat() {
        System.out.println("一天一苹果，医生远离我。");
    }
}
package Lambda2Package;

public class Test {
    public static void main(String[] args) {
        Eatable e = new EatableImpl();
        useEatable(e);

        useEatable(new Eatable() {
            @Override
            public void eat() {
                System.out.println("一天一苹果，医生远离我。");
            }
        });
           
        useEatbale(() -> {   
            System.out.println("一天一苹果，医生远离我。");
        });
    }

    public static void useEatable(Eatable e){
        e.eat();
    }
}
结果：
一天一苹果，医生远离我。
一天一苹果，医生远离我。
一天一苹果，医生远离我。

1.5、Lambda表达式的练习2

package Lambda2Package;

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

public class FlyableImpl implements Flyable {
    @Override
    public void fly(String s) {
        System.out.println(s);
    }
}
package Lambda2Package;

public class Test {
    public static void main(String[] args) {
        Flyable f = new FlyableImpl();
        useFlyable(f);

        System.out.println("-------------");

        useFlyable(new Flyable() {
            @Override
            public void fly(String s) {
                System.out.println(s);
                System.out.println("飞机自驾游。");
            }
        });

        System.out.println("-------------");

        //Lambda
        useFlyable((String s) -> {
            System.out.println(s);
            System.out.println("飞机自驾游。");
        });
    }

    public static void useFlyable(Flyable f){
        f.fly("风和日丽，晴空万里。");
    }
}
风和日丽，晴空万里。
-------------
风和日丽，晴空万里。
飞机自驾游。
-------------
风和日丽，晴空万里。
飞机自驾游。

1.6、Lambda表达式的练习3

package Lambda3Package;

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

public class AddableImpl implements Addable {
    @Override
    public int add(int x, int y) {
        return x + y;
    }
}
package Lambda3Package;

public class Test {
    public static void main(String[] args) {
        Addable a = new AddableImpl();
        useAddable(a);

        System.out.println("-----------");

        useAddable(new Addable() {
            @Override
            public int add(int x, int y) {
                return x + y;
            }
        });

        System.out.println("-----------");

        useAddable((int x, int y) -> {
            return x - y;
        });
    }

    public static void useAddable(Addable a) {
        int sum = a.add(1, 2);
        System.out.println(sum);
    }
}
结果：
3
-----------
3
-----------
-1

1.7、Lambda表达式的省略模式

省略规则：

  • 参数类型可以省略，但是有多个参数的情况下，不能只省略一个；
  • 如果参数有且仅有一个，那么小括号可以省略；
  • 如果代码块的语句只有一条，可以省略大括号和分号，甚至是return。

代码演示：

package Lambda4Package;

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

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

public class Test {
    public static void main(String[] args) {
        useAddable((int x, int y) -> {
            return x+y;
        });

        //参数的类型可以省略，但是有多个参数的情况下，不能只省略一个
        useAddable((x, y) -> {
            return x+y;
        });
        useFlyable((s) ->{
            System.out.println(s);
        });

        //如果参数有且仅有一个，那么小括号可以省略
        useFlyable(s -> {
            System.out.println(s);
        });

        //如果代码块的语句只有一条，可以省略大括号和分号
        useFlyable(s -> System.out.println(s));
        useAddable((x, y) -> x+y); //如果有return，return也省略掉
    }

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

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

1.8、Lambda表达式的注意事项

注意事项：

1、使用Lambda必须要有接口，并且要求接口中有且仅有一个抽象方法；

2、必须要有上下文环境，才能推导出Lambda对应的接口：

  • 根据局部变量的赋值得知Lambda对应的接口：Runnable r = () -> System.out.println("Lambda表达式");
  • 根据调用方法的参数得知Lambda对应的接口:new Thread( -> System.out.println("Lambda表达式")).start();

代码演示：

package Lambda5Package;

public interface Inter {
    void show(); //只能有一个抽象方法

    //void method();
}

package Lambda5Package;

public class Test {
    public static void main(String[] args) {
        //使用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 i){
        i.show();
    }
}
结果：
3
3
风和日丽，晴空万里。
风和日丽，晴空万里。
风和日丽，晴空万里。
3

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

1、所需类型不同：

  • 匿名内部类：可以是接口，也可以是抽象类，还可以是具体类。
  • Lambda表达式：只能是接口。

2、使用限制不同：

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

3、实现原理不同：

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

代码演示：

package Lambda6Package;

public interface Inter {
    void show();
    //void show2(); //只能有一个方法
}

package Lambda6Package;

public abstract class Animal {
    public abstract void method();
}

package Lambda6Package;

public class Student {
    public void study() {
        System.out.println("爱生活，爱Java");
    }
}
package Lambda6Package;

public class Test {
    public static void main(String[] args) {
        //匿名内部类
        useInter(new Inter() {
            @Override
            public void show() {
                System.out.println("接口"); //可以重写多个方法
            }
        });
        useAnimal(new Animal() {
            @Override
            public void method() {
                System.out.println("抽象类");
            }
        });
        useStudent(new Student(){
            @Override
            public void study() {
                System.out.println("具体类");
            }
        });

        //使用Lambda
        useInter(() -> System.out.println("接口")); //只有接口可以使用
        //useAnimal(() -> System.out.println("抽象类")); //抽象类不可以
        //useStudent(() -> System.out.println("具体类")); //具体类不可以

    }

    private static void useStudent(Student s){
        s.study();
    }

    private static void useAnimal(Animal a) {
        a.method();
    }

    private static void useInter(Inter i) {
        i.show();
    }
}
结果：
接口
抽象类
具体类
接口

啊噢1231
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Java语法之 Lambda表达式使用
liucy007的博客
09-27 756
匿名内部类，就是没有名字的一种嵌套类。它是Java对类的定义方式之一，最本质的还是一个类该类没有名字（但是系统会分配一个代号在内存中）
Lambda 表达式
YMFYZY的博客
07-08 153
这里用了我老师的笔记 Lambda 表达式 面向对象思想: ​ 做一件事情,找一个能够解决这个事情的对象,调用对象的方法来完成这件事情 函数式编程思想: ​ 重视的是结果,怎么做事情,不重视完成的过程,找谁来做 Lambda表达式作用:简化匿名内部类 lambda表达式使用前提:必须有接口,接口中有且只能有一个抽象方法(函数式接口) Lambda表达式是可推导,可省略:能推导出来,Lambda表达式重写的就是接口中唯一的抽象方法 (参数列表):重写抽象方法的参数 ->:传递(固定写法):可以把参数传
Java中Lambda表达式使用及详解
最新发布
做笔记\记录遇到的程序bug
07-17 1065
Lambda表达式（闭包）：java8的新特性，lambda运行将函数作为一个方法的参数，也就是函数作为参数传递到方法中。使用lambda表达式可以让代码更加简洁。Lambda表达式的使用场景：用以简化接口实现。关于接口实现，可以有很多种方式来实现。例如：设计接口的实现类、使用匿名内部类。但是lambda表达式，比这两种方式都简单。/*** Description:Lambda表达式//使用lambda表达式实现接口 Test test =() -> {
Java学习——lambda表达式
qq_45944185的博客
03-04 9606
lambda表达式
Java中的 Lambda表达式
bankser的博客
10-09 3499
文章目录前言一、Lambda表达式是什么？二、格式三、省略模式四、Lambda表达式和匿名内部类区别四、Lambda表达式支持的方法引用四、注意事项总结 前言 Lambda表达式是Java的学习过程中一个比较重要的点，它能让我们在编写代码的时候有更加清楚明了的逻辑。 一、Lambda表达式是什么？ Lambda表达式叫做函数式编程思想概述（函数式思想是尽量忽略面向对象的复杂语法：”强调做什么，而不是以什么形式去做“） 二、格式   1. ()：里面没有内容，可以看成是方法形式参数为空 ..
Java基础 学习笔记 Markdownr版
06-27
本学习笔记主要涵盖了Java的基础知识，包括面向对象、集合、IO流、多线程、反射与动态代理以及Java 8的新特性等方面，旨在帮助初学者或有经验的开发者巩固和提升Java编程技能。 1. 面向对象（OOP）：Java的核心是...
JAVA学习笔记————————
04-25
在深入探讨JAVA学习笔记之前，我们首先理解一下JAVA这一编程语言的重要性。JAVA，由Sun Microsystems公司（现已被Oracle收购）于1995年推出，是一种面向对象的、跨平台的编程语言，以其“一次编写，到处运行”的特性...
java jdk5.0学习笔记——良葛格
11-28
良葛格的《Java JDK5.0学习笔记》是一本面向初学者的教程，旨在帮助读者掌握这个版本的核心概念和技术。以下是基于该书部分内容的知识点详解： 1. **泛型**：JDK 5.0引入了泛型，这是一种强大的类型系统增强，允许...
良葛格Java JDK 5.0学习笔记
03-19
Java JDK 5.0是Java发展历程中的一个重要里程碑，它引入了许多新特性，极大地提升了开发效率和代码质量。..."良葛格Java JDK 5.0学习笔记"这份资料应该会详细解释这些概念，为初学者提供宝贵的参考资料。
JAVA多线程学习笔记整理（csdn）————程序.pdf
12-01
为了简洁，可以使用匿名内部类或Lambda表达式。 - **实现Runnable接口**：创建一个实现了Runnable接口的类，实现run()方法。然后创建一个Thread对象，将Runnable实例作为参数传入，并调用Thread对象的start()方法...
关于 Java Lambda 表达式看这一篇就够了（强烈建议收藏）
m0_73257876的博客
08-25 985
自定义函数接口很容易，只需要编写一个只有一个抽象方法的接口即可。// 自定义函数接口}上面代码中的@FunctionalInterface是可选的，但加上该标注编译器会帮你检查接口是否符合函数接口规范。就像加入@Override标注会检查是否重载了函数一样。...}}}// 使用自定义函数接口书写Lambda表达式。
java lambda无法使用_java – 为什么不允许lambda函数？
weixin_39537680的博客
02-13 1299
我一直在Vaadin的GUI中工作,有一些来自我的IT主管的课程.这一切都很棒,但是,今天,我遇到过我不能在addListener方法类型中使用lambda表达式.此方法是自定义的,作为使用它的对象.这是实施：public class ResetButtonForTextField extends AbstractExtension {private final List listeners= n...
java lambda表达式_恕我直言你可能真的不会java第1篇：lambda表达式会用了么？
weixin_39601794的博客
11-29 575
本文配套教学视频：B站观看地址 在本号之前写过的一些文章中，笔者使用了lambda表达式语法，一些读者反映说代码看不懂。本以为java 13都已经出了，java 8中最重要特性lambda表达式大家应该都掌握了，实际上还是存在大量的程序员没有使用java8，还有的使用了java8也不会使用lambda表达式。 Lambda表达式是Java 8最流行最常用的功能特性。它将函数式编程概念引入Java...
Java知识点汇总
无名小辈的博客
03-09 446
# Note-For-Java 记录一下java学习过程的重要知识点 #### 1.在java中如果被除数或者除数有一个为浮点类型，0或者0.0是可以用作除数的，结果得正负无穷；取余操作亦是如此。 #### 2.java在7.0之后switch语句case后面支持String类型。 #### 3.java嵌套循环中内部循环使用break或者continue来控制,外部循环结束或者跳过可以使用标签，...
JAVA中的Lambda表达式（“-＞“）用法
热门推荐
WYP123456L的博客
12-20 3万+
什么是Lambda? 我们知道，对于一个Java变量，我们可以赋给其一个“值”。 如果你想把“一块代码”赋给一个Java变量，应该怎么做呢？ 比如，我想把右边那块代码，赋给一个叫做aBlockOfCode的Java变量： 在Java 8之前，这个是做不到的。但是Java 8问世之后，利用Lambda特性，就可以做到了。 当然，这个并不是一个很简洁的写法。所以，为了使这个赋值操作更加elegant, 我们可以移除一些没用的声明。 这样，我们就成功的非常优雅的把“一块代码”赋给了一个
解决编写lambda表达式时出现lambda expressions are not supported at this language level问题
zhou_fan_xi的博客
11-05 8818
一、问题原因            IDEA编写lambda表达式时报错：lambda expressions are not supported at this language level，意思是在此语言级别不支持lambda表达式，即lambda表达式是java8才支持的一种语法，所以检查idea编译运行环境是否是java8及以上版本 二、问题解决            1. 打开 F...
java--Lambda （5）表达式的引用
程序员大腾的博客
11-24 451
如何引用Lambda表达式？ 引用是基于方法调用的事实提供一种简短的语法，让我们无需看完整的代码就能弄明白代码的意图。方法引用和构造器引用两类。类名::方法名类名::new静态方法引用；参数方法引用；实例方法引用。一般来说，方法实现比较简单、复用地方不多的时候推荐使用通常的 Lambda 表达式，
JAVA中的Lambda表达式
weixin_47600732的博客
03-28 6422
JAVA中的Lambda表达式 1.简介 1.Lambda表达式： JDK1.7版本以上推出新的特性，简单的说就是他没有声明的方法，也就是说没有访问修饰词，返回值等。 Lambda表达式用于创建匿名内部类所属的接口，必须只能有一个抽象方法，否则不可以使用Lambda表达式。 2.语法规则： （方法的参数）->{ 方法体 } 3.lambda表达式的标准格式由三部分组成： 1.一些参数 2.一个箭头 3.一段代码 4.格式说明： ()：接口中抽象方法参数，没有参数就空着，有参数就写参数，有多个参数就
java：解决 Lambda expressions are not supported at language level ‘5‘
weixin_50656879的博客
06-14 482
背景：通过lambda表达式写的代码一直飘红
Java 8 Lambda表达式与函数式接口学习笔记
"这份996视频学习笔记主要关注Java 8的新特性，包括lambda表达式、Stream API、Try-with-resource、Guava库的使用、线程池的管理和Lombok工具的介绍，以及验证框架的基本概念。" 在Java 8中，引入了lambda表达式，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值