λ希腊字母表中排序第十一位的字母，英文名称为Lambda

Lambda表达式，避免匿名内部类定义过多，代码看起来简洁

Lambda表达式，前提是函数式接口

其实质属于函数式编程的概念

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

a-> System.out.println("I love you-->" + a);

Runnable接口属于函数式接口，所以也可以使用Lambda表达式

new Thread(()->System.out.println("多线程Lambda表达式")).start();

Functional Interface（函数式接口），JDK8新增的

函数式接口定义

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

interface Run{
    void run();
}

2、通过Lambda表达式来创建函数式接口的对象

代码演示1：推导Lambda表达式

package com.jiemyx.lambda;

/*
推导lambda表达式
 */
public class TestLambda1 {
    //4、静态内部类
    static class Like2 implements ILike{
        @Override
        public void lambda() {
            System.out.println("I like lambda2");
        }
    }

    public static void main(String[] args) {
        //3、普通方式：实现对象，调用lambda()
        ILike l = new Like();
        l.lambda();

        l = new Like2();
        l.lambda();

        //5、局部内部类
        class Like3 implements ILike{
            @Override
            public void lambda() {
                System.out.println("I like lambda3");
            }
        }
        l = new Like3();
        l.lambda();

        //6、匿名内部类，没有类的名称，必须借助接口或者父类
        l = new ILike(){
            @Override
            public void lambda() {
                System.out.println("I like lambda4");
            }
        };
        l.lambda();

        //7、JDK8新增的Lambda，使用Lambda表达式来简化
        l = ()->{
            System.out.println("I like lambda5");
        };
        l.lambda();
    }
}

//1、定义一个函数式接口
interface ILike{
    void lambda();
}

//2、实现类
class Like implements ILike{
    @Override
    public void lambda() {
        System.out.println("I like lambda");
    }
}

运行结果：

I like lambda
I like lambda2
I like lambda3
I like lambda4
I like lambda5

代码演示2：Lambda表达式简化过程

package com.jiemyx.lambda;

public class TestLambda2 {

    public static void main(String[] args) {

        ILove l = (int a)-> {
            System.out.println("I love you-->" + a);
        };
        l.love(520);

        /*
        //1、简化类型
        ILove l = (a)-> {
            System.out.println("I love you-->" + a);
        };
        l.love(520);
        */

        /*
        //2、简化括号(只有单个参数的时候可以简化括号)
        ILove l = a-> {
            System.out.println("I love you-->" + a);
        };
        l.love(520);
        */

        /*
        //3、简化花括号（只有单行代码可以简化花括号）
        ILove l = a-> System.out.println("I love you-->" + a);
        l.love(520);
        */
    }
}

interface ILove{
    void love(int a);
}

运行结果：

I love you-->520

代码运行3：Lambda表达式多个参数和多个语句的简化

package com.jiemyx.lambda;

public class TestLambda3{

    public static void main(String[] args) {

        ILove2 l = (int a,int b,int c)-> {
            System.out.println("I love you-->" + a);
            System.out.println("I love you-->" + b);
            System.out.println("I love you-->" + c);
        };
        l.love(520,502,250);

        //简化类型
        /*ILove2 l = (a,b,c)-> {
            System.out.println("I love you-->" + a);
            System.out.println("I love you-->" + b);
            System.out.println("I love you-->" + c);
        };
        l.love(520,502,250);*/

        //有多个参数，不可以去掉括号

        //有多条语句，不可以去掉花括号，除非执行一条语句
        /*ILove2 l = (a,b,c)-> System.out.println("I love you-->" + a);
        l.love(520,502,250);*/
    }
}

interface ILove2{
    void love(int a,int b,int c);
}

//总结：
//1、lambda表达式前提接口为函数式接口
//2、多个参数可以去掉参数类型，必须都去掉，必须加上括号
//3、一行语句，可以去掉花括号简化；多条语句，需要用代码块（花括号）包裹

运行结果：

I love you-->520
I love you-->502
I love you-->250