java8_Lambda表达式详解

最新推荐文章于 2024-08-20 08:31:32 发布
最新推荐文章于 2024-08-20 08:31:32 发布
阅读量753 收藏 7
点赞数 6
分类专栏： java 文章标签： java lambda
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/MengHen_0_0/article/details/112694877
版权

Lambda表达式

1. 什么是Lambda表达式？

Lambda表达式是java8的新特性，是一个匿名函数。
java8为了实现lambda表达式对接口进行了修改，java8之前接口只能全部是抽象方法，但是为了实现lambda表达式对其进行了修改。
java8之后接口可以实现默认的方法，即default修饰的方法可以在接口中实现。

2. 为什么要使用Lambda表达式？

使用Lambda表达式可以对接口进行非常简洁的实现（就是为了实现接口的）。

3. Lambda表达式对接口的要求？

接口中只能有一个未被实现的方法。
在jdk中用 @FunctionalInterface 定义的接口都是可以使用lambda表达式实现匿名函数的。
如：
@FunctionalInterface
public interface Comparator

4. Lambda表达式基础语法

普通方法的语法关注：
返回值类型 方法名 参数类型 方法体
Lambda表达式语法关注：
lambda表达式是匿名函数，即不关注方法名；
lambda表达式的返回值类型不用显示的写出来；
所以：lambda表达式只关注：参数列+方法体
() : 用来描述参数列名（即普通方法的形式参数）
{ } : 用来描述方法体（和普通方法的方法体相同）
-> : 用来描述参数列名和方法体的关联
lambda表达式的基本语法是：（）-> { }

5. Lambda的基本使用
  1. 无参无返回值的接口实现
class LambdaTest01 {
    public static void main(String[] args) {
        Interface i = () -> { System.out.println("hello word"); };
        i.say();
    }
}
interface Interface{
    void say();
}
//输出：hello word
  1. 无参有返回值
public class LambdaTest02 {
    public static void main(String[] args) {
        Interface02 i = () -> {
            return 10;
        };
        int a = i.say();
        System.out.println(a);
    }
}

interface Interface02 {
    int say();
}
//输出：10
  1. 有一个参数，无返回值
public class LambdaTest03 {
    public static void main(String[] args) {
        Interface03 i = (int a) -> {
            System.out.println(a);
        };
        i.sum(10);
    }
}

interface Interface03 {
    void sum(int a);
}
//输出：10
  1. 有一个参数，有返回值
public class LambdaTest04 {
    public static void main(String[] args) {
        Interface04 i = (int a) -> {
            return a * 2;
        };
        System.out.println(i.sum(10));
    }
}

interface Interface04 {
    int sum(int a);
}
//输出：20
  1. 有多个参数无返回值
public class LambdaTest05 {
    public static void main(String[] args) {
        Interface05 i = (int a, int b) -> {
            System.out.println(a + b);
        };
        i.sum(10, 20);
    }
}

interface Interface05 {
    void sum(int a, int b);
}
//输出：30
  1. 有多个参数有返回值
public class LambdaTest06 {
    public static void main(String[] args) {
        Interface06 i = (int a, int b) -> {
            return a + b;
        };
        System.out.println(i.sum(10, 20));
    }
}

interface Interface06 {
    int sum(int a, int b);
}
6.Lambda表达式的精简
  1. 如果表达式中有参数，可以省略参数的参数类型
public class LambdaTest04 {
    public static void main(String[] args) {
        Interface04 i = (a) -> {
            return a * 2;
        };
        System.out.println(i.sum(10));
    }
}

interface Interface04 {
    int sum(int a);
}

(如果有多个参数，则全部参数的类型都必须省略)

public class LambdaTest06 {
    public static void main(String[] args) {
        Interface06 i = (a, b) -> {
            return a + b;
        };
        System.out.println(i.sum(10, 20));
    }
}

interface Interface06 {
    int sum(int a, int b);
}
  1. 如果表达式中的参数个数只有一个，小括号可以省略
public class LambdaTest04 {
    public static void main(String[] args) {
        Interface04 i = a -> {
            return a * 2;
        };
        System.out.println(i.sum(10));
    }
}

interface Interface04 {
    int sum(int a);
}
//输出：10
  1. 如果表达式中的方法体只有一条执行语句，大括号可以省略
  2. 如果表达式中的方法体中的一条语句是return语句，大括号和return要一起省略
public class LambdaTest03 {
    public static void main(String[] args) {
        Interface03 i = a -> System.out.println(a);
        i.sum(10);
    }
}

interface Interface03 {
    void sum(int a);
}

public class LambdaTest04 {
    public static void main(String[] args) {
        Interface04 i = a ->
                a * 2;

        System.out.println(i.sum(10));
    }
}

interface Interface04 {
    int sum(int a);
}
7.方法引用

如：

public class LambdaTest04 {
    public static void main(String[] args) {
        Interface04 i1 = a -> a * 2;
		Interface04 i2 = a -> a * 2;
		Interface04 i3 = a -> a * 2;
       	System.out.println(i1.sum(10) + i2.sum(20) + i3.sum(30));
    }
}

interface Interface04 {
    int sum(int a);
}

当程序的多个地方要用到实现都是一样的，那么就可以抽出一个方法去实现:
方法的参数必须和接口中的抽象方法参数相同

public class LambdaTest04 {
    public static void main(String[] args) {
        Interface04 i1 = a -> chage(a);
        Interface04 i2 = a -> chage(a);
        Interface04 i3 = a -> chage(a);

        System.out.println(i1.sum(10) + i2.sum(20) + i3.sum(30));
    }

    private static int chage(int a) {
        return a * 2;
    }
}

interface Interface04 {
    int sum(int a);
}
8.构造方法的引用

Person类

class Person {
    public String name;
    public int age;

    public Person() {
        System.out.println("使用的Person的无参构造");
    }

    public Person(String name, int age) {
        System.out.println("使用的Person的有参构造");
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

获取Person对象的抽象方法

interface PersonCreate {
    Person getPerson();
}

测试类（原始的Lambda表达式）

public class LambdaTest07 {
    public static void main(String[] args) {
        PersonCreate p = () -> {
            return new Person();
        };
        p.getPerson();
    }

}

语法精简

PersonCreate p = () -> {  return new Person(); };

只有一条语句（省略大括号和return语句）：

PersonCreate p = () -> new Person();

再次精简：
构造方法的引用（类名::new）

PersonCreate p = Person::new ;

测试一下是否可以获得person对象
测试类：

public class LambdaTest07 {
    public static void main(String[] args) {
        PersonCreate p = Person::new ;
        p.getPerson();
    }
}
//打印：使用的Person的无参构造

两参构造一样，只是获取对象接口中参数和构造方法中的参数要相同
修改接口：

interface PersonCreate {
    Person getPerson(String name, int age);
}

测试类:

public class LambdaTest07 {
    public static void main(String[] args) {
        PersonCreate p = Person::new;
        p.getPerson("zhangsan", 20);
    }

}
//打印：使用的Person的有参构造
9.在集合中的使用

还是使用Person类

class Person {
    public String name;
    public int age;

    public Person() {
        //System.out.println("使用的Person的无参构造");
    }

    public Person(String name, int age) {
        //System.out.println("使用的Person的有参构造");
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

将person对象加入到list集合

public class LambdaTest08 {
    public static void main(String[] args) {
        List<Person> list = new ArrayList<>();
        list.add(new Person("zhangsan",18));
        list.add(new Person("lisi",20));
        list.add(new Person("wangwu",18));
        list.add(new Person("xianoming",16));
        
    }
}

使用list.sort( )排序,根据年龄从大到小排序

public class LambdaTest08 {
    public static void main(String[] args) {
        List<Person> list = new ArrayList<>();
        list.add(new Person("zhangsan",18));
        list.add(new Person("lisi",20));
        list.add(new Person("wangwu",18));
        list.add(new Person("xianoming",16));
        list.sort((o1, o2) -> o2.age - o1.age);
        System.out.println(list);
    }
}
//输出：
[Person{name='lisi', age=20}, Person{name='zhangsan', age=18}, Person{name='wangwu', age=18}, Person{name='xianoming', age=16}]

用list.forEach( )方法，遍历集合（System.out::println）

public class LambdaTest08 {
    public static void main(String[] args) {
        List<Person> list = new ArrayList<>();
        list.add(new Person("zhangsan",18));
        list.add(new Person("lisi",20));
        list.add(new Person("wangwu",18));
        list.add(new Person("xianoming",16));
        list.sort((o1, o2) -> o2.age - o1.age);
        //System.out.println(list);
        list.forEach(System.out::println);
    }
}
//输出：
Person{name='lisi', age=20}
Person{name='zhangsan', age=18}
Person{name='wangwu', age=18}
Person{name='xianoming', age=16}

删除集合元素，如果用foreach遍历删除，会报错
如：

public class LambdaTest08 {
    public static void main(String[] args) {
        List<Person> list = new ArrayList<>();
        list.add(new Person("zhangsan",18));
        list.add(new Person("lisi",20));
        list.add(new Person("wangwu",18));
        list.add(new Person("xianoming",16));
        list.sort((o1, o2) -> o2.age - o1.age);
        //System.out.println(list);
        //list.forEach(System.out::println);
        for(Person p : list){
            if(p.age>18){
                list.remove(p);
            }
        }
    }
}
//报错信息：
Exception in thread "main" java.util.ConcurrentModificationException
	at java.util.ArrayList$Itr.checkForComodification(ArrayList.java:901)
	at java.util.ArrayList$Itr.next(ArrayList.java:851)
	at com.java.LambdaTest08.main(LambdaTest08.java:16)
（具体信息百度可以处理，这里不多解释，继续）

如果想实现删除可以用迭代器，或者从0 ~ size - 1 遍历元素
lambda可以使用list.removeIf( )删除集合元素

public class LambdaTest08 {
    public static void main(String[] args) {
        List<Person> list = new ArrayList<>();
        list.add(new Person("zhangsan",18));
        list.add(new Person("lisi",20));
        list.add(new Person("wangwu",18));
        list.add(new Person("xianoming",16));
        list.sort((o1, o2) -> o2.age - o1.age);
        //System.out.println(list);
        //list.forEach(System.out::println);
        /*for(Person p : list){
            if(p.age>18){
                list.remove(p);
            }
        }*/
        list.removeIf(person -> person.age >18);
        list.forEach(System.out::println);
    }
}
//输出：
Person{name='zhangsan', age=18}
Person{name='wangwu', age=18}
Person{name='xianoming', age=16}
（删除成功）
10.在线程中的使用

使用lambda前

public class LambdaTest09 {
    public static void main(String[] args) {
        Thread t = new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("启动线程");
            }
        });
        t.start();
    }
}
//输出：线程启动

使用lambda后

public class LambdaTest09 {
    public static void main(String[] args) {
        Thread t = new Thread(() -> System.out.println("线程启动"));//因为只有一句话，简写
        t.start();
    }
}
//输出：线程启动
11.系统内置函数式接口

jdk系统内部也封装了好多可以用Lambda表达式去实现的接口
Predicate(参数T；返回值boolean）（子类IntPredicate、LongPredicate、DoublePredicate)、
Consumer(参数T；返回值void)(子类IntConsumer、LongConsumer、DoubleConsumer)、
Function<T,R>（参数T；返回值R）、
Supplier(参数无；返回值T)、
UnaryOperator<T,T>(参数T；返回值T)、
BinaryOperator<T,T>(参数T，T；返回值T)、
BiFunction<T,U,R>(参数T，U；返回值R)、
BiPredicate<T,U>(参数T，U；返回值boolean)、
BiConsumer<T,U>(参数T，U；返回值void)）

public class LambdaTest10 {
    public static void main(String[] args) {
    
        int n = getNumber().get();
        
        System.out.println(n);
    }

    private static Supplier<Integer> getNumber() {
        int num = 10;
        return () -> {
            return num;
        };
    }
}
//输出：10

public class LambdaTeat11 {
    public static void main(String[] args) {
        int a = 10;//注意：这个a会提升至final ,不可以执行++或其他操作

        Consumer<Integer> c = ele ->{
            System.out.println(a);
        };
        
        c.accept(1);
    }
}
//输出：10

总结：Lambda表达式可以减少代码冗余，提高代码的执行效率。

借鉴于：https://www.bilibili.com/video/BV164411E7Ny

添加
 //四大接口基本用法
        //1.断言式
        Predicate pre = o -> o != null;
        List<Integer> list = new ArrayList<>();
        boolean test = pre.test(list);
        System.out.println(test);
        //2.函数式
        Function<Integer,Integer> function = a -> a * a;
        Integer apply = function.apply(4);
        System.out.println(apply);
        Function<Integer, Integer> s = function.andThen(function);
        Integer appl = s.apply(4);
        System.out.println(appl);
        //3.消费式
        Consumer<Integer> consumer = o -> System.out.println(o);
        consumer.accept(5);
        //4.供应式
        Supplier<Integer> supplier = () -> (int)(Math.random() * 5);
        Integer integer = supplier.get();
        System.out.println(integer);

隐式实现接口：

//内部类方式
interface Interface {
    List<Integer> getResult(int m);
}

public class Test01 {
    public static class Test02{
        public static List<Integer> getResult(int m){
            List<Integer> list = new ArrayList<>();
            for(int i = 0;i < m ; i++){
                list.add(i);
            }
            return list;
        }
        static Interface anInterface = Test02::getResult;
    }
public static void main(String[] args) {
        System.out.println(Test02.anInterface.getResult(5));
}
}
梦转千痕
关注
专栏目录
Java 8 lambda表达式引入详解及实例
08-30
"Java 8 lambda表达式引入详解及实例" Java 8 中引入的 lambda 表达式是一种新的编程方式，能够简化代码、提高开发效率。下面将对 lambda 表达式的引入、基本概念、使用方法和实例进行详细的介绍。 lambda 表达式...
【Java8】Lambda表达式 和 Stream API 详解笔记.zip
11-26
【Java8】Lambda表达式 和 Stream API 是Java编程语言中的两个重要创新，它们极大地提升了代码的简洁性和可读性，特别是在处理集合数据时。这里我们将深入探讨这两个特性，并结合实际示例来理解它们的工作原理。 ...
Java8 新特性Lambda表达式实例详解
08-31
主要介绍了Java8 新特性Lambda表达式实例详解的相关资料,需要的朋友可以参考下
Lambda表达式详解
07-02 241
Lambda表达式详解 前言 1、天真热，程序员活着不易，星期天，也要顶着火辣辣的太阳，总结这些东西。 2、夸夸lambda吧：简化了匿名委托的使用，让你让代码更加简洁，优雅。据说它是微软自c#1.0后新增的最重要的功能之一。 lambda简介 lambda...
带你彻底搞懂lambda表达式，超详细
最新发布
qq_36916968的博客
08-20 781
很多人以为 Lambda 只是让代码写得简洁些，方便些。但实际上，Lambda 表达式是一把威力巨大的工具，它打破了传统函数的限制，融合了闭包、泛型、移动语义等现代 C++ 特性，几乎可以解决所有场景中的问题。从简单的排序到复杂的异步任务，Lambda 无处不在，威力无穷。下次当你用 Lambda 表达式时，不妨想一想，它带来的不仅是代码的简化，更是编程思想的升华！
java8 手把手教你学会写lambda表达式
热门推荐
bitcarmanlee的博客
04-16 7万+
Java8发布已经有一段时间了，这次发布的改动比较大，很多人将这次改动与Java5的升级相提并论。Java8其中一个很重要的新特性就是lambda表达式，允许我们将行为传到函数中。想想看，在Java8 之前我们想要将行为传入函数，仅有的选择就是匿名内部类。Java8发布以后，lambda表达式将大量替代匿名内部类的使用，简化代码的同时，更突出了原来匿名内部类中最重要的那部分包含真正逻辑的代码。尤其
Java8 Lambda表达式用法详解
怪咖@的博客
05-17 3095
Lambda 是一个匿名函数，我们可以把 Lambda 表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）。使用它可以写出更简洁、更灵活的代码。
Java 8 Lambda 表达式详解
zhang33565417的博客
12-03 484
lambda 表达式，相信大家都不陌生，就算没有用过，那应该也听说过。我也是一样，在使用新特性 stream流处理集合相关的代码时接触到这种语法，其他地方倒是不经常使用。所以也是仅仅知道一些皮毛，对于其中的原理什么的也不怎么清楚。 今天准备系统的学习一番，话不多说，接下来就开始我们的学习。 lambda 表达式介绍 lambda 表达式是 Java 8 的一个新特性，可以取代大部分的匿名内部类，简化了匿名委托的使用，让你让代码更加简洁，优雅。 比较官方的定义是这样的： lambda 表达式是一个可传递的代
Java8 Lambda表达式详解及实例
09-01
Lambda表达式使得Java 8能够更好地支持函数式编程，让代码更简洁、可读性更强，尤其在处理集合、并发以及事件驱动编程时显得尤为重要。通过结合函数接口，Lambda表达式可以方便地应用于方法引用、流API等高级特性中...
Java8新特性Lambda表达式详解
老男孩的架构路
08-16 255
Lambda 是一个匿名函数，可以把 Lambda 表达式理解为是一段可以传递的代码（将代码像数据一样进行传递）。使用它可以写出更简洁、更灵活的代码。作为一种更紧凑的代码风格，使 Java 的语言表达能力得到了提升。和方法引用类似，函数式接口的抽象方法的形参列表和构造器的形参列表一致。抽象方法的返回值类型即为构造器所属的类的类型。方法引用可以看做是 Lambda 表达式深层次的表达。：Lambda形参列表，若为空则()->{};: Lambda操作符，箭头操作符。用于检查该接口是否为函数式接口。...
JAVA8 Lambda表达式详解
Cloud的专栏
08-04 1359
语法基础 java8中lambda表达式主要用来解决java中函数式编程语法太拖沓。 什么是函数式编程呢，我们来看个例子。 下面的代码是根据字符串长度来排序 List<String> strs = new ArrayList<>(); strs.add("123"); strs.add("123456"); strs.add("12"); Collections.sort(strs, new Comparator<String>() { @Overr
java8 Lambda表达式详细讲解
qq_42087460的博客
09-28 356
Lambda 表达式，它是推动 Java 8 发布的最重要新特性。 Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）。 使用 Lambda 表达式可以使代码变的更加简洁紧凑。 Lambda几种特性 可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。 可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。 可选的大括号：如果主体包含了一个语句，就不需要使用大括号。 可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定
java8的Lambda详解
persistence勿忘初心
02-21 745
(jdk1.8)Lambda 表达式实质是一个可以实现某一接口的匿名内部类的中的方法 Lambda表达式组成部分 括号包起来的参数 (若参数仅有一个 可省略括号) 一个箭头 既 (-> 操作符) 方法体，可以是单个语句，也可以是语句块 (若是单个语句 则可以直接写出结尾不需要; 结束，若为语句块则两边需加入花括号，每局结尾以; 结束) 参数可以写类型，也可以不写， 方法可以有返回，也...
Java 8 Lambda的详解说明
qq_25073223的博客
10-18 166
Java 8 Lambda的详解说明
Java8 lambda表达式
jeikerxiao
04-28 452
1. 实现Runnable线程案例 可以使用下面语法实现Lambda: 1. (params) -&gt; expression 2. (params) -&gt; statement 3. (params) -&gt; { statements } 例如：方法接受两个方法参数。 (int even, int odd) -&gt; even + odd 推荐简写： (int...
Java8特性详解 lambda表达式 Stream
u014754272的博客
03-15 411
1.lambda表达式 Java8最值得学习的特性就是Lambda表达式和Stream API，如果有python或者javascript的语言基础，对理解Lambda表达式有很大帮助，因为Java正在将自己变的更高（Sha）级（Gua），更人性化。--------可以这么说lambda表达式其实就是实现SAM接口的语法糖。 lambda写的好可以极大的减少代码冗余，同时可读性也好过冗长的内部...
【Java8新特性】——Lambda表达式详解
你看到的逆袭，只不过是一场预备很久，草蛇灰线，伏笔千里的反攻
06-04 501
【前言】 Lamda是一个匿名函数，可以把lamda表达式理解为一段可以传递的代码，可以写出简洁，更加灵活的代码。作为一种更加紧凑的代码风格，使Java的语言表达式能力得到了提升。 【内容】 1.为什么要用Lamda表达式？ 从案例中我们找出答案： 例如从员工中分别找出工资小于5000的员工，找出年龄大于35的员工； //员工的集合： List&lt;Employee&gt...
Lambda 表达式
qq_41864967的博客
08-27 249
1. 引言 在 Java 8 以前，若我们想要把某些功能传递给某些方法，总要去写匿名类。以前注册事件监听器的写法与下面的示例代码就很像： manager.addScheduleListener(newScheduleListener(){ @Override publicvoidonSchedule(ScheduleEvente){ ...
Java8 Lambda表达式详解与实战应用
"Java8中的Lambda表达式教程深入解析" Java8的Lambda表达式是一种简洁且强大的特性，它允许程序员在代码中直接传递函数或操作，而无需创建完整的类或匿名内部类。这一改变使得Java语言更加灵活，提高了代码的可读性...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值