---

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("我是外部类");
    }
}

运行结果

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);
}