Lambda表达式

最新推荐文章于 2024-07-04 09:24:51 发布
最新推荐文章于 2024-07-04 09:24:51 发布
阅读量140 收藏
点赞数
文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44355642/article/details/125169636
版权

Lambda表达式

标准格式

示例

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

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

(形式参数) -> {代码块}
//形式参数：可以有多个，用逗号隔开，也可以没有，即留空
//箭头：代表指向动作
//代码块：具体要实现的动作

使用方法

1、需要有一个接口

2、在类中定义一个方法使用该接口

3、调用该方法，使用Lambda表达式简化书写

省略写法

  • 参数类型可以省略（要么都写，要么都省略）
  • 如果参数只有一个，参数小括号可以省略
  • 如果代码块只有一行语句，代码块大括号可以省略，分号也可以省略
    • 如果该行语句中有return，则return必须要省略

注意事项

  • 接口中有且仅有一个抽象方法
  • 必须有上下文环境，才能推导出Lanbda对应的接口

Lambda和匿名内部类区别

  • Lambda表达式只能使用含有一个方法的接口，匿名内部类可以使用多方法接口、抽象类、具体类
  • Lambda表达式不会产生新的字节码文件，匿名内部类会产生新的字节码文件

方法引用

方法引用符

：：

该符号为方法引用符，它所在的表达式称为方法引用

示例

//Lambda表达式
usePrintable(s -> System.out.println(s));
//方法引用
usePrintable(System.out::println);

引用类方法

引用类的静态方法

类名 :: 静态方法

示例

//接口
public interface Converter {
    int convert(String s);
}
//测试类
public class ConverterDemo {
    public static void main(String[] args) {
        //Lambda表达式
        useConverter((String s)->{return Integer.parseInt(s);});//完整写法
        useConverter(s->Integer.parseInt(s));//省略写法
        //引用类方法
        useConverter(Integer::parseInt);

    }
    private static void useConverter(Converter c){
        int num=c.convert("897");
        System.out.println(num);
    }
}

引用对象实例方法

引用类中的成员方法

对象::成员方法

示例

//接口
public interface Printer {
    void printUpperCase(String s);
}
//引用对象类
public class PrintString {
    public void printUpper(String s){
        System.out.println(s.toUpperCase());
    }
}
//测试类
public class PrinterDemo {
    public static void main(String[] args) {
        //Lambda表达式
        //标准写法
        usePrinter((String s) -> {
            System.out.println(s.toUpperCase());
        });
        //省略写法
        usePrinter(s -> System.out.println(s.toUpperCase()));
        //引用对象实例方法
        PrintString printString = new PrintString();
        usePrinter(printString::printUpper);
    }

    private static void usePrinter(Printer p) {
        p.printUpperCase("abcdefg");
    }
}

引用类的实例方法

应用类中的成员方法

类名::成员方法

示例

//接口
public interface MyString {
    String mySubString(String s, int x, int y);
}
//测试类
public class MyStringDemo {
    public static void main(String[] args) {
        //Lambda表达式
        useMyString((String s, int x, int y) -> {
            return s.substring(x, y);
        });
        useMyString((s, x, y) -> s.substring(x, y));
        //引用类的实例方法
        //第一个参数作为调用者，后面的全部参数作为该方法的参数进行传递
        useMyString(String::substring);
    }

    private static void useMyString(MyString m) {
        String result = m.mySubString("abcdefghigklmn", 3, 6);
        System.out.println(result);
    }
}

引用构造器

引用构造方法

类名：：new

示例

//接口
public interface StudentBuilder {
    Student build(String name, int age);
}
//学生类
public class Student {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}
//测试类
public class StudentDemo {
    public static void main(String[] args) {
        //Lambda表达式
        useStudentBuilder((String name, int age) -> {
            return new Student(name, age);
        });
        useStudentBuilder((name, age) -> new Student(name, age));
        //引用构造器
        useStudentBuilder(Student::new);
    }

    private static void useStudentBuilder(StudentBuilder s) {
        Student stu = s.build("刘晨旭", 27);
        System.out.println(stu.getName() + ":" + stu.getAge());
    }
}

函数式接口

概述

有且仅有一个抽象方法的接口，即可以适用Lambda表达式的接口

@FunctionalInterface//标识该接口为函数式接口
public interface MyInterface {
    void show();
}

函数式接口作为方法的参数

示例

//接口
public interface Runnable {
    public abstract void run();
//测试类
public class RunnableDemo {
    public static void main(String[] args) {
        //匿名内部类
        startThread(new Runnable() {
            @Override
            public void run() {
                System.out.println(Thread.currentThread().getName()+"线程启动了");
            }
        });
        //Lambda表达式
        startThread(() -> System.out.println(Thread.currentThread().getName() + "线程启动了"));
    }

    private static void startThread(Runnable r) {
        Thread thread = new Thread(r);
        thread.start();
    }
}

函数式接口作为方法返回值

可以使用Lambda表达式作为结果返回

示例

public class ComparatorDemo {
    public static void main(String[] args) {
        ArrayList<String> arrayList = new ArrayList<>();
        arrayList.add("aaaa");
        arrayList.add("c");
        arrayList.add("bbb");
        System.out.println("排序前:" + arrayList);
        Collections.sort(arrayList);
        System.out.println("自然排序后:" + arrayList);
        Collections.sort(arrayList, getComparator());
        System.out.println("比较器排序后:" + arrayList);
    }

    private static Comparator<String> getComparator() {
        //匿名内部类
//        Comparator<String> com = new Comparator<String>() {
//            @Override
//            public int compare(String o1, String o2) {
//                return o1.length()-o2.length();
//            }
//        };
//        return com;
        //Lambda表达式
        return (String s1, String s2) -> {
            return s1.length() - s2.length();
        };
    }
}

常用的函数式接口

Supplier接口

软件包 java.util.function

用于生产数据

Modifier and Type方法描述
Tget()获得结果。
public class SupplierDemo {
    public static void main(String[] args) {
        String s = getString(() -> "刘晨旭");
        System.out.println(s);
        int num = getInteger(() -> 27);
        System.out.println(num);
    }

    private static String getString(Supplier<String> s) {
        return s.get();
    }

    private static Integer getInteger(Supplier<Integer> s) {
        return s.get();
    }
}

Consumer接口

对参数进行操作

软件包 java.util.function

  • 表示接受单个输入参数并且不返回结果的操作。 与大多数其他功能接口不同， Consumer预期通过副作用进行操作。
Modifier and Type方法描述
voidaccept(T t)对给定的参数执行此操作。
default Consumer<T>andThen(Consumer<? super T> after)返回一个组成的 Consumer ，依次执行此操作，然后执行 after操作。

示例

public class ConsumerDemo {
    public static void main(String[] args) {
        operatorString("刘晨旭", s -> System.out.println(s));
        operatorString("郭浩年", System.out::println);
        operatorString("今天真是一个好日子", s -> System.out.println(s), s -> System.out.println(new StringBuilder(s).reverse().toString()));

    }

    private static void operatorString(String s, Consumer<String> con) {
        con.accept(s);
    }

    private static void operatorString(String s, Consumer<String> con1, Consumer<String> con2) {
        con1.andThen(con2).accept(s);
    }
}

Predicate接口

对参数进行判断

软件包 java.util.function

Modifier and Type方法描述
default Predicate<T>and(Predicate<? super T> other)返回一个组合的谓词，表示该谓词与另一个谓词的短路逻辑AND。
default Predicate<T>negate()返回表示此谓词的逻辑否定的谓词。
default Predicate<T>or(Predicate<? super T> other)返回一个组合的谓词，表示该谓词与另一个谓词的短路逻辑或。
booleantest(T t)在给定的参数上评估这个谓词。

示例

public class PredicateDemo01 {
    public static void main(String[] args) {
        boolean b1 = check("acb", s -> s.length() > 5);
        System.out.println(b1);
        boolean b2 = check("abcdefg", s -> s.length() > 5, s -> s.length() < 15);
        System.out.println(b2);

    }

    private static boolean check(String s, Predicate<String> pre) {
        return pre.test(s);
        //逻辑非
//        return pre.negate().test(s);
    }

    private static boolean check(String s, Predicate<String> pre1, Predicate<String> pre2) {
        //逻辑或
//        return pre1.or(pre2).test(s);
        //逻辑与
        return pre1.and(pre2).test(s);
    }
}

Function接口

软件包 java.util.function

Modifier and Type方法描述
default <V> Function<T,V>andThen(Function<? super R,? extends V> after)返回一个组合函数，首先将该函数应用于其输入，然后将 after函数应用于结果。
Rapply(T t)将此函数应用于给定的参数。

示例

public class FunctionDemo {
    public static void main(String[] args) {
        convert("456123",s->Integer.parseInt(s));
        add(90,num->String.valueOf(num+10));
        add("9999",Integer::parseInt,num->String.valueOf(num+1));

    }

    private static void convert(String s, Function<String,Integer> fun){
        int num = fun.apply(s);
        System.out.println(s);
    }
    private static void add(Integer num,Function<Integer,String> fun){
        String str = fun.apply(num);
        System.out.println(str);
    }
    private static void add(String s,Function<String,Integer> fun1,Function<Integer,String> fun2){
        String str = fun1.andThen(fun2).apply(s);
        System.out.println(str);
    }
}
HIT_Demon
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C++ 中lambda表达式的编译器实现原理
08-31
C++中的Lambda表达式是C++11引入的一项重要特性，它允许程序员在代码中定义匿名函数，并且可以直接在定义的地方使用。Lambda表达式的引入极大地增强了C++的可读性和简洁性，尤其是在处理函数对象和回调函数时。下面...
C#基础之Lambda表达式用法实例教程
09-04
Lambda表达式是C#语言中的一个强大特性，它在C# 3.0及更高版本中引入，使得代码更加简洁、可读性更强。Lambda表达式主要用于创建匿名函数，它可以被赋值给变量，作为参数传递，或者用作方法的返回值。在本教程中，...
JAVA使用ASM实现lambda表达式的字节码
小李的博客
03-10 1155
接下来加号的问题就比较复杂了，方法字节码与原java代码反汇编出来的结果已经完全一致了，javap的参数都试过了一遍也搜不到"+",但是经过idea的反编译出来的显示效果就是不一样，为了探究这个问题，得顺着先去了解下idea的反编译手段，根据idea的注释“对照上面的反汇编字节码可以慢慢理清楚每个参数的含义，至于方法参数为何是这些，可以在源码注释中找到答案。这是一个非常简单的lambda表达式的方法，话不多说，我们开始编码。明显是错的，那么接下来我们把重要的那部分补充完整。最后附上javap的一些参数吧。
Lambda表达式超详细总结
热门推荐
huangjhai的博客
07-07 9万+
在2014年Oracle发布了Java 8,在里面增加了Lambda模块。于是Java程序员们又多了一种新的编程方式：函数式编程。
Lambda表达式详解
唯有努力，方可自信！
06-14 6848
本篇文章将介绍Java中的Lambda表达式，它是Java 8中引入的一项新特性，也是函数式编程的一种风格。我们将深入研究Lambda表达式的语法和用法，讲解如何使用Lambda表达式来写出更加简洁、易读的代码，并介绍Lambda表达式在Java中的应用场景及其优缺点。无论您是初学者还是有一定经验的程序员，本文都将为您提供宝贵的参考和帮助。
C++11：lambda表达式
Man9o
03-09 1万+
通常lambda表达式用于封装一些传递给算法或异步函数的代码。C++11中引入了λ表达式，它可以用来定义一个**内联 (inline)**的函数，作为一个本地的对象或者一个参数。内联函数是一种编译器优化技术，它可以避免函数调用的开销，提高执行效率。λ表达式可以被编译器自动内联展开，从而减少函数调用的次数。但是，并不是所有的λ表达式都会被内联，这取决于编译器的实现和优化策略。
Lambda 表达式
小鲁蛋的博客
08-21 4438
Lambda 是一个匿名函数，我们可以把 Lambda 表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）。使用它可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升。Lambda 表达式：在Java 8 语言中引入的一种新的语法元素和操作符。这个操作符为 “->” ， 该操作符被称为Lambda 操作符或箭头操作符。左边：lambda形参列表 （其实就是接口中的抽象方法的形参列表）
C ++ Lambda表达式详解
白云之道
12-19 4万+
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
Java Lambda 表达式
Yeats_Liao的博客
04-15 3万+
Java Lambda 表达式
【Java系列】深入解析 Lambda表达式
颜淡慕潇
06-23 5万+
Lambda表达式是Java 8中最强大和灵活的新特性之一，它可以用于各种不同的编程任务，使代码更加简单、灵活和易于读写。 Lambda表达式的语法非常简洁，通常由一个参数列表、一个箭头符号和一个表达式主体组成。
Java 8 lambda表达式
06-27
java lambda表达式,lambda 表达式基本上表达了函数式接口的实例（具有单一抽象方法的接口称为函数式接口。一个例子是 java.lang.Runnable）。lambda 表达式实现了唯一的抽象函数，因此实现了函数式接口 lambda ...
Stream、Lambda表达式练习.doc
01-14
Stream和Lambda表达式实践 在Java中，Stream API是Java 8中引入的一种新的数据处理方式，它可以对集合进行各种操作，如过滤、映射、聚合等。Lambda表达式是Java 8中引入的一种新的函数式编程方式，它可以将函数作为...
C++11 lambda表达式
12-22
C++11引入了lambda表达式，使得程序员可以定义匿名函数，该函数是一次性执行的，既方便了编程，又能防止别人的访问。 　Lambda表达式的语法通过下图来介绍： 　这里假设我们定义了一个如上图的lambda表达式。...
JVM原理（十一）：JVM虚拟机六种必需对类进行初始化的情况
zuodingquan666的博客
07-03 526
Java虚拟机把描述类的数据从Class文件加载到内存，并对数据进行校验、转换解析和初始化，最终形成可以被虚拟机直接使用的Java类型，这个过程被称作虚拟机的类加载机制。Java天生可以动态扩展的语言特性就是依赖运行期间动态加载和动态链接这个特点实现的。
ShardingSphere
最新发布
Casual_Lei的博客
07-04 648
ShardingSphere 通过提供数据分片、分布式事务、数据加密和读写分离等功能，帮助开发者轻松构建高性能、高可用的分布式数据库系统。其灵活的架构设计和丰富的功能模块，使其成为现代分布式数据库中间件的优秀选择。
java 程序、进程 、线程，cpu，并行、并发、启动线程两种方式
gu2022_3_5_21_23的博客
07-02 339
Thread 方式 线程间不可以共享数据，除非变量加 static 变为 静态变量 （每次创建实例，会有一个新的副本）。条件二： 重写 Thread 父类方法 后创建实例调用 start 方法 （创建匿名子类的匿名对象）条件一： 将创建自实现 Runable 接口后的实例 作为参数传递给 Thread 的构造方法。2、将创建自实现 Runable 接口后的实例 作为参数传递给 Thread 的构造方法。最后调用的都是 Thread 的start 的方法。创建的线程对象，都是Thread类或其子类的实例。
maven配置使用nexus仓库
ApexPredator的博客
07-03 226
maven配置使用nexus仓库
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、付费专栏及课程。

余额充值