Lambda表达式超详细总结（简单易懂）

水深无声 2024-03-30 15:10 35阅读 0赞

#### 文章目录 ####

*   *   *   *  1、什么是Lambda表达式
             *  2、为什么使用Lambda表达式
             *  3、函数式接口（lambda表达式的使用前提）
             *  4、推导Lambda表达式
             *  5、Lambda表达式语法

--------------------

##### 1、什么是Lambda表达式 #####

Lambda表达式，也可称为闭包。其本质属于函数式编程的概念，是Java8发布的最重要的新特性。

##### 2、为什么使用Lambda表达式 #####

*  避免匿名内部类定义过多
 *  可以写出更简洁、更灵活的代码，只留下来核心的逻辑

##### 3、函数式接口（lambda表达式的使用前提） #####

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

public interface Runnable{
        
         public abstract void run();
    }

*  对于函数式接口，我们可以通过lambda表达式来创建该接口的对象

##### 4、推导Lambda表达式 #####

由外部类、成员内部类、静态内部类、局部内部类、匿名内部类推导出Lambda表达式(**使用前提必须是实现函数式接口**)

/**
     * 代码推导Lambda表达式
     */
    public class LambdaDemo {
        
        /**
         * 成员内部类
         */
        class Love2 implements ILove {
        
            @Override
            public void run() {
        
                System.out.println("我是成员内部类");
            }
        }
    
        /**
         * 静态内部类
         */
        static class Love3 implements ILove {
        
            @Override
            public void run() {
        
                System.out.println("我是静态内部类");
            }
        }
    
        public static void main(String[] args) {
        
    
            /**
             * 局部内部类（在main里）
             */
            class Love4 implements ILove {
        
                @Override
                public void run() {
        
                    System.out.println("我是局部内部类");
                }
            }
    
            /**
             * 匿名内部类（没有类的名称，必须借助接口或者父类）
             */
            ILove love5 = new ILove() {
        
                @Override
                public void run() {
        
                    System.out.println("我是匿名内部类");
                }
            };
    
            /**
             * 用Lambda简化
             */
            ILove love6 = () -> {
        
                System.out.println("我是Lambda简化版");
            };
    
            //1.外部内部类方式
            ILove love1 = new Love1();
            love1.run();
    
            //2.成员内部类方式
            LambdaDemo lambdaDemo = new LambdaDemo();
            ILove love2 = lambdaDemo.new Love2();
            love2.run();
    
            //3.静态内部类方式
            ILove love3 = new Love3();
            love3.run();
    
            //4.局部内部类
            ILove love4 = new Love4();
            love4.run();
    
            //5.匿名内部类
            love5.run();
    
            //6.用Lambda简化
            love6.run();
        }
    }
    
    //定义一个函数式接口
    interface ILove {
        
        void run();
    }
    
    /**
     * 外部实现类
     */
    class Love1 implements ILove {
        
        @Override
        public void run() {
        
            System.out.println("我是外部类");
        }
    }

运行结果

![image-20230105224353853][]

##### 5、Lambda表达式语法 #####

Lambda表达式在Java语言中引入了一个操作符==->==，该操作符被称为Lambda操作符或箭头操作符。它将Lambda分为两个部分：

*  左侧：指定了Lambda表达式需要的所有参数
 *  右侧：制定了Lambda体，即Lambda表达式要执行的功能。

(parameters) -> expression[表达式]
     (parameters) -> statement[语句]
      (parameters) -> {
        statement}

(1)语法格式一：无参，无返回值，Lambda体只需一条语句。如下：

public class LambdaDemo {
        
        public static void main(String[] args) {
        
            Ilove love = null;
            love = ()->{
        
                System.out.println("接口方法无参数，无返回值" );
            };
            love.run();
        }
    }
    interface ILove {
        
        void run();
    }

(2)语法格式二：有一个参数(此时参数类型和小括号都可以省略，代码只有一行的时候，花括号也可以省略)，无返回值,

love = a-> System.out.println(“接口只有一个参数，无返回值” + a);  
love = (a)-> System.out.println(“接口只有一个参数，无返回值” + a);

public class LambdaDemo {
        
        public static void main(String[] args) {
        
            Ilove love = null;
            //1.简化参数类型
            love = a->{
        
                System.out.println("接口只有一个参数，无返回值" + a);
            };
            love.run(1314);
        }
    }
    interface Ilove{
        
        void run(int a);
    }
    
    
    public class LambdaDemo {
        
        public static void main(String[] args) {
        
            Ilove love = null;
            //2.简化花括号（代码只有一行时）
            love = a-> System.out.println("接口只有一个参数，无返回值" + a);
            love.run(1314);
        }
    }
    interface Ilove{
        
        void run(int a);
    }

(3)语法格式三：有两个参数（参数类型可以省略，但小括号不可以省略），有返回值，并且Lambda体有多条执行语句。

public class LambdaDemo {
        
        public static void main(String[] args) {
        
            //1.简化参数类型
            Ilove love = (a, b) -> {
        
                System.out.println("接口只有两个个参数，有返回值");
                return a+b;
            };
            int run = love.run(1314, 521);
            System.out.println(run);
        }
    }
    
    interface Ilove {
        
        int run(int a, int b);
    }

(4)语法格式四：Lambda体只有一条语句(**return和花括号都可以省略。如果花括号省略，return一定要省略**)。

public class LambdaDemo {
        
        public static void main(String[] args) {
        
            //1.简化参数类型
            Ilove love = (a, b) -> a+b;
            int run = love.run(1314, 521);
            System.out.println(run);
        }
    }
    
    interface Ilove {
        
        int run(int a, int b);
    }

[image-20230105224353853]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/9d1537079ce442ada6f849e212640dd1.png