Java多线程-lambda表达式

绝地灬酷狼 2023-09-27 08:29 9阅读 0赞

## 什么是lambda 表达式 ##

它是Java8函数式接口(function interface),Lambda 表达式（lambda expression）是一个匿名函数，Lambda表达式基于数学中的λ演算得名，直接对应于其中的lambda抽象（lambda abstraction），是一个匿名函数，即没有函数名的函数。Lambda表达式可以表示闭包（注意和数学传统意义上的不同）

![在这里插入图片描述][8191eb6fdf834b659e98eaefbbc10c77.png]

## 为什么要用lambda表达式 ##

1 避免匿名内部类定义过多

2 key让代码看起来更加整洁

3 去掉一推没有意义的代码,只留下核心的逻辑

lambda 表达式可以简化我们的代码本质属于函数式编程

## 函数式接口的定义 ##

1 任何接口,如果只包含唯一一个抽象方法，那么它就是函数式接口

runnable接口就是一个lambda表达式  
![在这里插入图片描述][76615dffdafe4565aca5cbc5b3417b73.png]

//比如Runnable接口中的run方法   一个接口只有唯一一个抽象方法,就是函数式接口,就可以用lamda表达式创建该接口的对象
    public interface Runnable{
        
        public abstract void run();
    }

2 对于函数式接口,我们可以使用lambda表达式来创建该接口的对象

package com.wyh.lamda;
    
    /**
     * @program: Thread
     * @description: lambda表达式测试
     * @author: 魏一鹤
     * @createDate: 2021-12-30 22:39
     **/
    
    //3 静态内部类
    
    //推导lambda表达式
    public class TestLambda1 {
        
      static  class Like2 implements ILike {
        
    
            @Override
            public void lambda() {
        
                System.out.println("I Like Lambda2");
            }
        }
    
        public static void main(String[] args){
        
                //用接口去创建对象  接口去new它的实现类
                ILike like=new Like();
                like.lambda();
    
                like= new Like2();
                like.lambda();
    
                //4 局部内部类
            class Like3 implements ILike {
        
    
                @Override
                public void lambda() {
        
                    System.out.println("I Like Lambda3");
                }
            }
            like=new Like3();
            like.lambda();
    
            //5 匿名内部类,没有类的名称,必须借助接口或者父类
            like=new ILike() {
        
                @Override
                public void lambda() {
        
                    System.out.println("I Like Lambda4");
                }
            };
            like.lambda();
            //6 用lambda简化
           like=()-> {
        
                System.out.println("I Like Lambda5");
            };
           like.lambda();
        }
    }
    //1 定义一个函数式接口
    interface ILike{
        
        abstract  void lambda();
    }
    //2 实现类  去实现接口
    class Like implements ILike {
        
        @Override
        public void lambda() {
        
            System.out.println("I Like Lambda");
        }
    }

## 例子 ##

下面是一个带参数的lambda表达式的例子

package com.wyh.lamda;
    
    /**
     * @program: Thread
     * @description: Lambda表达式
     * @author: 魏一鹤
     * @createDate: 2021-12-30 23:00
     **/
    
    public class TestLambda2 {
        
        //静态内部类
    
        public static void main(String[] args){
        
    
            //1 lambda表达式简化
            ILove love =(int num)-> {
        
                System.out.println("I Love You -->"+num);
            };
    
            //简化1 去掉参数类型
            love=(num)-> {
        
                System.out.println("I Love You -->"+num);
            };
            // 简化2  去掉括号
            love=num-> {
        
                System.out.println("I Love You -->"+num);
            };
            //简化3 去掉花括号
            love=num->System.out.println("I Love You -->"+num);
    
            //总结
            //lambda表达式只能有一行代码的情况下才能简化成一行,如果有多行,那么就用代码块({}花括号)包裹
            //前提是函数式接口 接口只有一个方法
            //多个参数也可以去掉数据类型,要去掉都去掉,要留下都留下,必须加括号把参数括起来(a,b)
            love.ILove(520);
    
    
    
        }
    }
    //定义一个函数式接口 带参数
    interface  ILove{
        
        void ILove(int num);
    }
    //定义类实现接口
    class Love implements ILove {
        
    
        @Override
        public void ILove(int num) {
        
            System.out.println("I Love You -->"+num);
        }
    
    }

## 简化方式 ##

简化1 去掉参数类型

love=(num)-> {
        
        System.out.println("I Love You -->"+num);
    };

简化2 去掉括号

love=num-> {
        
        System.out.println("I Love You -->"+num);
    };

简化3 去掉花括号

love=num->System.out.println("I Love You -->"+num);

## 代码总结 ##

1 lambda表达式只能有一行代码的情况下才能简化成一行,如果有多行,那么就用代码块(\{\}花括号)包裹

2 前提是函数式接口 接口只有一个方法

3 多个参数也可以去掉数据类型,要去掉都去掉,要留下都留下,必须加括号把参数括起来(a,b)

最终简化代码

package com.wyh.lamda;
    
    /**
     * @program: Thread
     * @description: Lambda表达式
     * @author: 魏一鹤
     * @createDate: 2021-12-30 23:00
     **/
    
    public class TestLambda2 {
        
        //静态内部类
    
        public static void main(String[] args){
        
    
            ILove love;
            // 简化2  去掉括号
            love=(num,num2,num3)-> {
        
                System.out.println("I Love You -->"+num);
            };
    
    
            //总结
            //lambda表达式只能有一行代码的情况下才能简化成一行,如果有多行,那么就用代码块({}花括号)包裹
            //前提是函数式接口 接口只有一个方法
            //多个参数也可以去掉数据类型,要去掉都去掉,要留下都留下,必须加括号把参数括起来(a,b)
            love.ILove(520,123,232);
    
    
    
        }
    }
    //定义一个函数式接口 带参数
    interface  ILove{
        
        void ILove(int num,int num2,int num3);
    }
    //定义类实现接口
    class Love implements ILove {
        
    
        @Override
        public void ILove(int num1,int num2,int num3) {
        
            System.out.println("I Love You -->"+num1);
        }
    
    }

[8191eb6fdf834b659e98eaefbbc10c77.png]: https://img-blog.csdnimg.cn/8191eb6fdf834b659e98eaefbbc10c77.png
[76615dffdafe4565aca5cbc5b3417b73.png]: https://img-blog.csdnimg.cn/76615dffdafe4565aca5cbc5b3417b73.png