JavaSE Lambda 表达式

最新推荐文章于 2023-03-14 15:07:58 发布
最新推荐文章于 2023-03-14 15:07:58 发布
阅读量149 收藏
点赞数
分类专栏： JavaSE 文章标签： java javase lambda
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46651512/article/details/113935059
版权

JavaSE Lambda 表达式

1. Lambda 表达式

1.1 函数式编程思想概述

在这里插入图片描述
在数学中，函数就是有输入量、输出量的一套计算方案，也就是 “拿数据做操作”
面向对象思想强调 “必须通过对象的形式来做事情”
函数式思想则尽量忽略面向对象的复杂语法，强调 “做什么，而不是以什么形式去做”
而我们要学的 Lambda 表达式就是函数式思想的体现

1.2 体验Lambda表达式

需求：启动一个线程，在控制台输出一句话：半仙儿努力考研

  • 方式1：

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

  • 方式2：
    匿名内部类的方式改进

  • 方式3：
    Lambda表达式的方式改进

package FH.Lambda01;

public class MyRunnable implements Runnable{

    @Override
    public void run() {
        System.out.println("半仙儿努力考研");
    }
}


package FH.Lambda01;
/*
    需求：
        启动一个线程，在控制台输出一句话：半仙儿努力考研
 */
public class LambdaDemo {
    public static void main(String[] args){
        //实现类的方式实现需求
//        MyRunnable my = new MyRunnable();
//        Thread t = new Thread(my);
//        t.start();

        //匿名内部类的方式改进
//        Thread t2 = new Thread(new Runnable() {
//            @Override
//            public void run() {
//                System.out.println("半仙儿努力考研");
//            }
//        });
//        t2.start();

        //Lambda表达式的方式改进
//        Thread t= new Thread( () -> {
//            System.out.println("半仙儿努力考研");
//        } );
//        t.start();
        new Thread( () -> {
            System.out.println("半仙儿努力考研");
        } ).start();
    }
}

1.3 Lambda 表达式的标准格式

  • 匿名内部类中重写run()方法的代码分析：
    1. run()方法的形式参数为空，说明调用方法时不需要传递参数
    2. 方法返回值类型为 void，说明方法执行没有结果返回
    3. 方法体中的内容，是我们具体要做的事情

在这里插入图片描述

  • Lambda 表达式的代码分析：
    1. ( )：里面没有内容，可以看成是方法形式参数为空
    2. ->：用箭头指向后面要做的事情
    3. { }：包含一段代码，称之为代码块，可以看成是方法体中的内容

在这里插入图片描述

  • Lambda表达式的三要素：

    1. 形式参数
    2. 箭头
    3. 代码块

  • Lambda 表达式的标准格式：

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

1.4 Lambda 表达式的练习

  • Lambda表达式的使用前提：
    1. 有一个接口
    2. 接口中有且仅有一个抽象方法

1.4.1 练习1（抽象方法无参无返回值）

  • 定义一个接口（Eatable），里面有一个抽象方法：void eat();
  • 定义一个测试类（EatableDemo），在测试类中提供两个方法：
    useEatable(Eatable e)
    main()，在主方法中调用useEatable方法
package FH.Lambda02;

public interface Eatable {
    void eat();
}


package FH.Lambda02;

public class EatableImpl implements Eatable{
    @Override
    public void eat() {
        System.out.println("干饭啦!!!");
    }
}


package FH.Lambda02;
/*
    练习1：
    定义一个接口（Eatable），里面有一个抽象方法：void eat();
    定义一个测试类（EatableDemo），在测试类中提供两个方法：
        useEatable(Eatable e)
        main()，在主方法中调用useEatable方法
 */
public class EatableDemo {
    public static void main(String[] args){
        //在主方法中调用useEatable方法
        Eatable e = new EatableImpl();
        useEatable(e);

        //匿名内部类
        useEatable(new Eatable() {
            @Override
            public void eat() {
                System.out.println("干饭啦!!!");
            }
        });

        //Lambda表达式
        useEatable(() -> {
            System.out.println("干饭啦!!!");
        });
    }

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

1.4.2 练习2（抽象方法带参无返回值）

  • 定义一个接口（Flyable），里面有一个抽象方法：void fly(String s);
  • 定义一个测试类（FlyableDemo），在测试类中提供两个方法：
    useFlyable(Flyable f)
    main()，在主方法中调用useFlyable方法
package FH.Lambda03;

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


package FH.Lambda03;
/*
    练习2：
    定义一个接口（Flyable），里面有一个抽象方法：void fly(String s);
    定义一个测试类（FlyableDemo），在测试类中提供两个方法：
        useFlyable(Flyable f)
        main()，在主方法中调用useFlyable方法
 */
public class FlyableDemo {
    public static void main(String[] args){
        useFlyable(new Flyable() {
            @Override
            public void fly(String s) {
                System.out.println(s);
            }
        });

        useFlyable((String s) -> {
            System.out.println(s);
        });
    }

    private static void useFlyable(Flyable f) {
        f.fly("半仙儿");
    }
}

1.4.3 练习3（抽象方法带参带返回值）

  • 定义一个接口（Addable），里面有一个抽象方法：int add(int x,int y);
  • 定义一个测试类（AddableDemo），在测试类中提供两个方法：
    useAddable(Addable a)
    main()，在主方法中调用useAddable方法
package FH.Lambda04;

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


package FH.Lambda04;
/*
    练习3：
    定义一个接口（Addable），里面有一个抽象方法：int add(int x,int y);
    定义一个测试类（AddableDemo），在测试类中提供两个方法：
        useAddable(Addable a)
        main()，在主方法中调用useAddable方法
 */
public class AddableDemo {
    public static void main(String[] args){
        useAddable(new Addable() {
            @Override
            public int add(int x, int y) {
                return x+y;
            }
        });
        useAddable((int x,int y) -> {
            return x + y;
        });
    }

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

1.5 Lambda 表达式的省略模式

Lambda 表达式的省略规则：

  1. 参数类型可以省略，多个参数的情况下不能只省略一个
  2. 如果参数有且仅有一个，小括号可以省略
  3. 如果代码块的语句只有一条，可以省略大括号和分号，如果有return，return也要省略
package FH.Lambda05;
/*
    Lambda表达式的省略模式
 */
public class LambdaDemo {
    public static void main(String[] args){
        useAddable((int x,int y) -> {
            return x + y;
        });
        //1.参数的类型可以省略
        useAddable((x,y) -> {
            return x + y;
        });
        useFlyable((s) -> {
            System.out.println(s);
        });

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

        //如果代码块的语句只有一条，可以省略大括号和分号
        useFlyable(s -> System.out.println(s));

        //3.如果代码块的语句只有一条，可以省略大括号和分号，如果有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(367, 376);
        System.out.println(sum);
    }
}

1.6 Lambda 表达式的注意事项

  1. 使用Lambda必须要有接口，且接口中有且仅有一个抽象方法
  2. 必须有上下文环境，才能推导出Lambda对应的接口
    1. 根据 局部变量的赋值 得知Lambda对应的接口：Runnable r = () -> System.out.println(“半仙儿努力考研”);
    2. 根据 调用方法的参数 得知Lambda对应的接口：new Thread(() -> System.out.println(“半仙儿努力考研”)).start();
package FH.Lambda06;

public interface Inter {
    void show();
}


package FH.Lambda06;

public class LambdaDemo {
    public static void main(String[] args){
        //使用Lambda表达式必须要有接口，并且接口中有且仅有一个抽象方法
        useInter(() -> System.out.println("半仙儿努力考研"));

        //必须有上下文环境，才能推导出Lambda对应的接口
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("半仙儿努力考研");
            }
        }).start();
//        () -> System.out.println("半仙儿努力考研");//单独的Lambda没有意义
        Runnable r = () -> System.out.println("半仙儿努力考研");
        new Thread(r).start();

        new Thread(() -> System.out.println("半仙儿努力考研")).start();
    }
    private static void useInter(Inter i){
        i.show();
    }
}

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

  1. 所需类型不同
    1. 匿名内部类：可以是接口，抽象类，具体类
    2. Lambda表达式：只能是接口
  2. 使用限制不同
    1. 如果接口中有且仅有一个抽象方法，可以使用Lambda表达式，也可以使用匿名内部类
    2. 如果接口中多于一个抽象方法，只能使用匿名内部类
  3. 实现原理不同
    1. 匿名内部类：编译之后，产生一个单独的 .class字节码文件
    2. Lambda表达式：编译之后，没有一个单独的 .class字节码文件，对应字节码会在运行的时候动态生成
package FH.Lambda07;

public interface Inter {
    void show();
    void show2();
}


package FH.Lambda07;

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


package FH.Lambda07;

public class Student {
    public void study(){
        System.out.println("半仙儿努力考研");
    }
}


package FH.Lambda07;

public class LambdaDemo {
    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("具体类"));


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

            @Override
            public void show2() {
                System.out.println("show2");
            }
        });

    }
    private static void useStudent(Student s){
        s.study();
    }
    private static void useAnimal(Animal a){
        a.method();
    }
    private static void useInter(Inter i){
        i.show();
    }
}
苦瓜bug
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
（Java学习笔记）JavaSE Lambda表达式
陌然白（小白）的博客
04-20 465
Lambda表达式1.为什么使用Lambda表达式2、Lambda表达式规则2.1、格式2.2、语法格式3、函数式(Functional)接口4、方法引用与构造器引用4.1、方法引用(Method References)4.2、构造器引用与数组引用 Lambda 表达式为java1.8的新特性，引入的一种新的语法元素和操作符 “->”。 1.为什么使用Lambda表达式 Lambda ...
【JavaSE】Lambda表达式、接口组成更新、方法引用
一个正在努力学习的iter
05-23 377
文章目录1. Lambda表达式1.1 Lambda表达式初体验1.2 Lambda表达式的基本格式1.3 Lambda表达式练习1.4 Lambda表达式的省略规则1.5 Lambda表达式的注意事项1.6 Lambda表达式和匿名内部类的区别2. 接口组成更新2.1 接口组成更新概述2.2 接口中默认方法应用2.3 接口中静态方法应用2.4 接口中私有方法应用3. 方法引用3.1 方法引用初体验3.2 方法引用符3.3 方法引用类对象练习3.4 方法引用对象的实例方法3.5 方法引用类的实例方法3.6
Java8 Lambda表达式教程
热门推荐
io
10-16 26万+
Java8新特性，Lambda表达式与集合类bulk operation教程。迄今为止最全面的中文原创java lambda表达式教程。
JavaSE—— Lambda表达式
Java
12-26 102
Java Lambda表达式
JavaSE Lambda表达式(JDK1.8新特性)
weixin_30664539的博客
04-15 96
在前面有一篇写到了Lambda表达式,现在可以给你们介绍什么是Lambda表达式 现在有很多老程序员都不喜欢这个函数式编程思想 　　主要就一点 : 老程序员习惯了面向过程写程序,而Lambda表达式是 面向结果 不注重过程 那么Lambda有什么优点 : 操作简单 代码优化 缺点 : 非常不易读 Lambda标准格式 Lambda省去面向对象的条条框框，...
【JavaSE】Lambda表达式
苹果不肖皮的博客
03-12 142
一、基本用法 Lambda 表达式的核心目的是为了简化函数式接口的匿名内部类。 Lambda 表达式由三部分组成： 形参列表。允许省略形参类型。若只有一个形参，圆括号也可省略。 箭头（->）。 代码块。如果代码块只有一条语句，允许省略花括号。 （1）定义一个函数式接口。 @FunctionalInterface public interface Eatable { void eat(String name); } （2）匿名内部类的写法 Eatable eatable = new Eat
java的lambda表达式,Java语言级别不支持lambda表达式“
weixin_30942339的博客
02-22 1129
I was testing out some new features of Java 8 and copied the example into my IDE (Eclipse originally, then IntelliJ) as shown here:http://docs.oracle.com/javase/tutorial/java/javaOO/examples/RosterTes...
Java【lambda表达式】语法及使用方式介绍
yzhcjl_的博客
03-14 2917
由于正在更新 Java【EE初阶】部分中多线程相关的文章，lambda表达式 是多线程编程中很常用的语法功能，本篇将分享 lambda表达式 相关的内容, 主要介绍 lambda表达式 的使用方式 以及在集合中的一些应用如果看到这篇文章的读者们正处于 Java 基础语法阶段，只要有【类和对象、接口】部分的基础就可以无压力学会 lambda表达式 的基本操作提示：是正在努力进步的小菜鸟一只，如有大佬发现文章欠佳之处欢迎评论区指点~ 废话不多说，直接发车~函数式接口。
JAVA中的Lambda表达式
weixin_47600732的博客
03-28 6402
JAVA中的Lambda表达式 1.简介 1.Lambda表达式： JDK1.7版本以上推出新的特性，简单的说就是他没有声明的方法，也就是说没有访问修饰词，返回值等。 Lambda表达式用于创建匿名内部类所属的接口，必须只能有一个抽象方法，否则不可以使用Lambda表达式。 2.语法规则： （方法的参数）->{ 方法体 } 3.lambda表达式的标准格式由三部分组成： 1.一些参数 2.一个箭头 3.一段代码 4.格式说明： ()：接口中抽象方法参数，没有参数就空着，有参数就写参数，有多个参数就
Lambda表达式.xmind
03-11
JavaSE,jdk8新特性，Lambda表达式思维导图
java8新特性Lambda表达式
最新发布
05-23
想要快速了解并掌握Lambda表达式的可以学习
探索Java语言与JVM中的Lambda表达式
01-31
Lambda表达式是自JavaSE5引入泛型以来最重大的Java语言新特性，本文将介绍Lamdba的设计初衷，应用场景与基本语法。Lambda表达式，这个名字由该项目的专家组选定，描述了一种新的函数式编程结构，这个即将出现在Java ...
JavaSE-example:JavaSE部分示例代码，包括Java基础，Java高级特性（IO，集合，网络编程，多线程），Java8新特性（Lambda表达式，stream等）
03-06
JavaSE示例 JavaSE部分示例代码，包括Java基础，Java高级特性（IO，集合，网络编程，多线程），Java8新特性（Lambda表达式，stream等）
JavaSE精华笔记.zip
01-06
Java基础部分笔记，包含IO流、多线程、网络编程、Lambda表达式，适合巩固基础以及新手查看，都是Java基础的精华
JavaSE 方法
苦瓜的博客
10-31 3874
JavaSE 方法方法概述方法的定义方法的定义和调用方法的定义方法的调用带参数方法的定义和调用带参数方法定义带参数方法的调用带返回值带返回值方法的定义和调用方法的注意事项方法重载方法的参数传递 方法概述 方法的定义 方法 是将具有独立功能的 代码块 组织成为一个整体，使其具有特殊功能的 代码集。 注意： 方法必须先创建才可以使用，该过程称为 方法定义。 方法创建后并不是直接运行的，需要手动使用后才执行，该过程称为 方法调用。 方法的定义和调用 方法的定义 格式： public static void
JavaSE 面向对象基础
苦瓜的博客
11-06 2879
JavaSE类和对象对象内存图成员变量和局部变量封装构造方法 类和对象 对象内存图 成员变量和局部变量 封装 构造方法
JavaSE运算符
苦瓜的博客
10-28 2309
运算符算术运算符运算符和表达式算术运算符字符的 " + " 操作字符串的 " + " 操作赋值运算符赋值运算符自增自减运算符自增自减运算符关系运算符逻辑运算符三元运算符 算术运算符 运算符和表达式 运算符：对常量或者变量进行操作的符号。 表达式：用运算符把常量或者变量连接起来符合Java语法的式子称为表达式。不同运算符连接的表达式体现的是不同类型的表达式。 算术运算符 加（＋） 减（－） 乘（×） 除（/） 取余（%） int a = 6; int b = 4; System.out.println
JavaSE 形参和返回值（引用类型）
苦瓜的博客
11-28 2119
JavaSE 形参和返回值形参和返回值类名作为形参和返回值 形参和返回值 类名作为形参和返回值
我要JavaSE的学习规划
03-31
1. 学习基础知识：首先要学习JavaSE的...6. 学习新技术：了解JavaSE的新技术，如Lambda表达式、Stream API等，跟上JavaSE的发展趋势。 7. 不断练习：JavaSE的学习需要不断的练习和实践，只有经过实践才能真正掌握。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值