java补完——λLamda表达式属于JDK1.8后（2014.3.18）

文章说明：黑色字体-已知，蓝色字体-所见即所得，红色字体-还需要再找资料弄明白的，黄色背景-提炼关键信息
参考资料：很多参考资料，段落下有原文链接到原作者

Lamda表达式（λ）须知

λ：希腊字母，第十一位。
应用场景：http://www.codebelief.com/article/2018/01/java-lambda-expression-common-application-scenarios/
1.为什么要使用Lamda表达式
避免匿名内部类定义过多、简洁代码、去掉没有意义的代码，留下核心逻辑。
2.Lamda表达式的书写格式（看完推到过程记住语法就可以用Lamda了）
new Thread（()->System.out.println(“Lamda表达式”)）.start()
一条简化：函数式接口 对象 = 参数 -→ 内容
多条简化：函数式接口 对象 =（a,b）-→{内容}
注：不要误会，接口不能实例化。
3.Lamda表达式的前提（关键）
Functional Interface（函数式接口）：只包含一个抽象方法。可以通过lambda表达式来创建函数式接口的对象。
4、Lamda表达式须知（结合推导过程看）
1）多个参数去掉参数类型，去就都去掉，保留就都保留，但是必须加上括号。
2）只有在方法中含有一条语句的情况下，才可以去掉{}。多条语句，不可去掉{}。

Lamda表达式推导过程

实现类→静态内部类→局部内部类→匿名内部类→Lamda表达式。
实现类：

public class TestLambda {
    public static void main(String[] args) {
        //实例化一个对象，调用方法
        Lambda1 lambda1 = new Lambda1();
        lambda1.lambdaMethod();
    }
}
//定义一个函数式接口：一个接口有且仅有一个方法；
interface LambdaInterface {
    void lambdaMethod();
}
//实现类
class Lambda1 implements LambdaInterface {

    @Override
    public void lambdaMethod() {
        System.out.println("Lambda1");
    }
}

静态内部类：

public class TestLambda {
    //静态内部类
    static class Lambda1 implements LambdaInterface {
        @Override
        public void lambdaMethod() {
            System.out.println("Lambda1");
        }
    }
    public static void main(String[] args) {
        //实例化一个对象，调用方法
        Lambda1 lambda1 = new Lambda1();
        lambda1.lambdaMethod();
    }
}
//定义一个函数式接口：一个接口有且仅有一个方法；
interface LambdaInterface {
    void lambdaMethod();
}

局部内部类：

public class TestLambda {
    public static void main(String[] args) {
        //局部内部类，注意要把它放在实例化之前
        class Lambda1 implements LambdaInterface {
            @Override
            public void lambdaMethod() {
                System.out.println("Lambda1");
            }
        }
        //实例化一个对象，调用方法
        Lambda1 lambda1 = new Lambda1();
        lambda1.lambdaMethod();
    }
}
//定义一个函数式接口：一个接口有且仅有一个方法；
interface LambdaInterface {
    void lambdaMethod();
}

匿名内部类：

public class TestLambda {
    public static void main(String[] args) {
        //匿名内部类：没有类的名称，必须借助接口或父类；
        LambdaInterface testLambda = new LambdaInterface() {
            @Override
            public void lambdaMethod() {
                System.out.println("Lambda1");
            }
        };
        testLambda.lambdaMethod();
    }
}
//定义一个函数式接口：一个接口有且仅有一个方法；
interface LambdaInterface {
    void lambdaMethod();
}

Lamda表达式：

public class TestLambda {
    public static void main(String[] args) {
        //匿名内部类：没有类的名称，必须借助接口或父类；
        LambdaInterface testLambda = new LambdaInterface() {
            @Override
            public void lambdaMethod() {
                System.out.println("Lambda1");
            }
        };
        testLambda.lambdaMethod();
        //用Lambda简化
        testLambda = () -> {
            System.out.println("Lambda2");
        };
        testLambda.lambdaMethod();
    }
}
//定义一个函数式接口：一个接口有且仅有一个方法；
interface LambdaInterface {
    void lambdaMethod();
}

Lamda表达式2：

public class TestLambda2 {
    public static void main(String[] args) {
        LambdaInterface2 lambdaInterface2 = null;
        //Lambda简化1：
        lambdaInterface2 = (int b) -> {
            System.out.println("简化1--->数值 = " + b);
        };
        lambdaInterface2.value(88);
        //Lambda简化2：简化参数类型
        //当有多个参数时，他们的参数类型要去掉就都去掉，要不然就都不去掉！！！
        lambdaInterface2 = (b) -> {
            System.out.println("简化2--->数值 = " + b);
        };
        lambdaInterface2.value(100);
        //Lambda简化3：简化括号
        //当有多个参数时，括号不可以被去掉！！！
        lambdaInterface2 = b -> {
            System.out.println("简化3--->数值 = " + b);
        };
        lambdaInterface2.value(99);
        //Lambda简化4：简化花括号
        //当方法体{}中只有一条执行语句(即：只有一个分号)时，才可以这样简化！！！
        //若方法体{}中有多条语句，必须用花括号{}包裹着；
        lambdaInterface2 = (b) -> System.out.println("简化4--->数值 = " + b);
        lambdaInterface2.value(77);
    }
}
interface LambdaInterface2 {
    void value(int b);
}

原文链接：https://blog.youkuaiyun.com/weixin_45683851/article/details/103302081