详解 Lambda表达式

youzgLogo

基本知识点：

概念：

Lambda 是一个匿名函数，
我们可以把 Lambda表达式理解为是一段可以传递的代码
（将代码像数据一样进行传递）
可以写出更简洁、更灵活的代码。
作为一种更紧凑的代码风格，使Java的语言表达能力得到了提升

此外，在讲解用法之前，本人要声明的一点是：

使用前提：

Lambda表达式仅适用于 函数式接口

函数式接口：
只含有一个抽象方法 的接口

那么，现在，本人就通过对于例子的简化，来讲解Lambda表达式的语法要求：

new 接口：

Lambda化格式：

接口名 接口对象 = (参数...) -> {
	方法体;
};

注意：

参数可以 不写类型

若 方法体只有一行return语句，则可以 省略大括号

首先，本人来给出一个接口：

package edu.youzg.about_new_features.core.about_jdk8.core;

public interface MyInterface {
    Object add(int a,int b);
}

那么，我们以往想要在使用这个接口的话，就要按如下的格式：

原始格式：

package edu.youzg.about_new_features.core.about_jdk8.core;

public class Test {

    public static void main(String[] args) {
        MyInterface myInterface = new MyInterface() {

            @Override
            public Object add(int a, int b) {
                return a + b;
            }
        };

        System.out.println(myInterface.add(10, 20));
    }

}

想必结果大家肯定都知道：
运行结果

那么，在我们引入Lambda表达式的知识后，就可以化简为如下格式：

一阶 · Lambda 版本：

package edu.youzg.about_new_features.core.about_jdk8.core;

public class Test {

    public static void main(String[] args) {
        //原始写法
        MyInterface myInterface = new MyInterface() {

            @Override
            public Object add(int a, int b) {
                return a + b;
            }
        };
        System.out.println(myInterface.add(10, 20));
        
        //Lambda表达式 * 一阶
        MyInterface myInterface1 = (int a, int b) -> {
            return a + b;
        };
        System.out.println(myInterface1.add(10, 20 ));
    }

}

那么，我们来看一下运行结果：

其实，参数类型也可以省略不写：

二阶 · Lambda 版本：

package edu.youzg.about_new_features.core.about_jdk8.core;

public class Test {

    public static void main(String[] args) {
        //原始写法
        MyInterface myInterface = new MyInterface() {

            @Override
            public Object add(int a, int b) {
                return a + b;
            }
        };
        System.out.println(myInterface.add(10, 20));
        
        //Lambda表达式 * 一阶
        MyInterface myInterface1 = (int a, int b) -> {
            return a + b;
        };
        System.out.println(myInterface1.add(10, 20 ));

        //Lambda表达式 * 二阶
        MyInterface myInterface2 = (a, b) -> {
            return a + b;
        };
        System.out.println(myInterface2.add(10, 20 ));
    }

}

令人惊叹的是：
由于实现这个接口，我们 只写了一行return，
所以，源代码块还可以 省去return和{}：

三阶 · Lambda 版本：

package edu.youzg.about_new_features.core.about_jdk8.core;

public class Test {

    public static void main(String[] args) {
        //原始写法
        MyInterface myInterface = new MyInterface() {

            @Override
            public Object add(int a, int b) {
                return a + b;
            }
        };
        System.out.println(myInterface.add(10, 20));
        
        //Lambda表达式 * 一阶
        MyInterface myInterface1 = (int a, int b) -> {
            return a + b;
        };
        System.out.println(myInterface1.add(10, 20 ));

        //Lambda表达式 * 二阶
        MyInterface myInterface2 = (a, b) -> {
            return a + b;
        };
        System.out.println(myInterface2.add(10, 20 ));

        //Lambda表达式 * 三阶
        MyInterface myInterface3 = (a, b) -> a + b;
        System.out.println(myInterface3.add(10, 20 ));
    }

}

那么，本人来展示下运行结果：

new接口时 new实体类：

Lambda化格式：

目标接口 接口实现类 = 目标实体类::new;

适用场景：

实现过程 最终通过 new这个实体类 为结尾
且接口的 未实现方法 的 返回值类型 与 该实体类的类型 一致
且 new 接口的参数 与 new该实体类的参数 一致

现在，本人来给出一个Model类：

package edu.youzg.about_new_features.core.about_jdk8.core;

public class Model {
    int value;
    int number;

    public Model(int value, int number) {
        System.out.println("执行了双参构造");
        this.value = value;
        this.number = number;
    }

    public int getValue() {
        return value;
    }

    public int getNumber() {
        return number;
    }

}

现在，若是本人想在该函数接口的抽象方法中返回一个刚申请对象的成员的值：

原始版本：

package edu.youzg.about_new_features.core.about_jdk8.core;

public class Test {

    public static void main(String[] args) {
        //原始写法
        MyInterface myInterface = new MyInterface() {
            @Override
            public Object add(int a, int b) {
                Model model = new Model(a, b);
                return model;
            }
        };
        Model add = (Model) myInterface.add(1, 2);
        System.out.println("value为：" + add.getValue() + "\r\nnumber为：" + add.number);
    }

}

那么，我们可以转换为如下格式：

Lambda 版本：

package edu.youzg.about_new_features.core.about_jdk8.core;

public class Test {

    public static void main(String[] args) {
        //原始写法
        MyInterface myInterface = new MyInterface() {
            @Override
            public Object add(int a, int b) {
                Model model = new Model(a, b);
                return model;
            }
        };
        Model add = (Model) myInterface.add(1, 2);
        System.out.println("value为：" + add.getValue() + "\r\nnumber为：" + add.number);

        System.out.println("===================================");
        //Lambda表达式 版本
        MyInterface myInterface1 = Model::new;
        Model add1 = (Model) myInterface.add(1, 2);
        System.out.println("value为：" + add1.getValue() + "\r\nnumber为：" + add1.number);
    }

}

现在，本人来展示下运行结果：

new接口时调用静态方法：

Lambda化格式：

目标接口 目标接口实现类 = 类名::静态方法名;

适用场景：

接口的 未实现方法 返回值为 void类型，
且 实现过程 仅通过 执行一个静态方法 而结束
且 new 接口的参数 与 该静态方法的参数 一致

实现过程 最终通过 执行一个方法 为结尾
且接口的 未实现方法 的 返回值类型 与 该方法的返回值类型 一致
且 new 接口的参数 与 该静态方法的参数 一致

原始格式：

package edu.youzg.about_new_features.core.about_jdk8.core;

public class Test {

    public static void main(String[] args) {
        //原始写法
        MyInterface myInterface = new MyInterface() {
            @Override
            public Object add(int a, int b) {
                int min = Math.min(a, b);
                return min;
            }
        };
        System.out.println(myInterface.add(10, 20));
    }

}

那么，对于这个转换，本人再来给出个例子：

Lambda 版本：

package edu.youzg.about_new_features.core.about_jdk8.core;

public class Test {

    public static void main(String[] args) {
        //原始写法
        MyInterface myInterface = new MyInterface() {
            @Override
            public Object add(int a, int b) {
                int min = Math.min(a, b);
                return min;
            }
        };
        System.out.println(myInterface.add(10, 20));

        System.out.println("===================================");
        //Lambda表达式 版本
        MyInterface myInterface1 = Math::min;
        System.out.println(myInterface1.add(10, 20));
    }

}

那么，本人再来展示下运行结果：
表达式

那么，现在，本人再来展示最后一种可转换条件 —— 非静态方法：

new接口时调用非静态方法：

Lambda化格式：

目标接口 目标接口实现类 = 执行对象::目标方法;

适用场景：

接口的 未实现方法 返回值为 void类型，
且 实现过程 最终通过 执行一个方法 为结尾

实现过程 最终通过 执行一个方法 为结尾
且接口的 未实现方法 的 返回值类型 与 该方法的返回值类型 一致

原始格式：

package edu.youzg.about_new_features.core.about_jdk8.core;

public class Test {

    public static void main(String[] args) {
        //原始写法
        MyInterface myInterface = new MyInterface() {
            @Override
            public Object add(int a, int b) {
                Model model = new Model(a, b);
                return model.plus(10, 20);
            }
        };
        System.out.println(myInterface.add(10, 20));
    }

}

Lambda 版本：

package edu.youzg.about_new_features.core.about_jdk8.core;

public class Test {

    public static void main(String[] args) {
        //原始写法
        MyInterface myInterface = new MyInterface() {
            @Override
            public Object add(int a, int b) {
                Model model = new Model(a, b);
                return model.plus(10, 20);
            }
        };
        System.out.println(myInterface.add(10, 20));

        System.out.println("===================================");
        //Lambda表达式 版本
        Model model = new Model(5, 1);
        MyInterface myInterface1 =  model::plus;
        System.out.println(myInterface1.add(10, 20));
    }

}

现在，本人来展示下运行结果：
最终展示

那么，有关Lambda表达式的所有可能出现的例子在上面就展示完毕了！
现在，本人来稍作总结：

总结：

操作符为 -> ，该操作符被称为 Lambda 操作符 或 箭头操作符
它将 Lambda 分为两个部分：

左侧：指定了 Lambda 表达式需要的 所有参数

右侧：指定了 Lambda 体，即 Lambda 表达式 要执行的功能

Lambda表达式 的结果一定是一个 函数式接口 的 实现类

方法引用：使用操作符 :: 将 方法名 和 对象或类 分隔开来，例如：

对象::实例方法
类::静态方法
类::实例方法

posted @ 2020-03-05 11:22 在下右转，有何贵干阅读(450) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

在下右转，有何贵干

带你深究Java的本质！

详解 Lambda表达式

基本知识点：

概念：

使用前提：

new 接口：

Lambda化格式：

原始格式：

一阶 · Lambda 版本：

二阶 · Lambda 版本：

三阶 · Lambda 版本：

new接口时 new实体类：

Lambda化格式：

适用场景：

原始版本：

Lambda 版本：

new接口时调用静态方法：

Lambda化格式：

适用场景：

原始格式：

Lambda 版本：

new接口时调用非静态方法：

Lambda化格式：

适用场景：

原始格式：

Lambda 版本：

总结：

公告

在下右转，有何贵干

带你深究Java的本质！

详解 Lambda表达式

基本知识点：

概念：

使用前提：

new 接口：

Lambda化 格式：

原始 格式：

一阶 · Lambda 版本：

二阶 · Lambda 版本：

三阶 · Lambda 版本：

new接口时 new实体类：

Lambda化 格式：

适用场景：

原始 版本：

Lambda 版本：

new接口时 调用 静态方法：

Lambda化 格式：

适用场景：

原始 格式：

Lambda 版本：

new接口时 调用 非静态方法：

Lambda化 格式：

适用场景：

原始 格式：

Lambda 版本：

总结：

公告

Lambda化格式：

原始格式：

Lambda化格式：

原始版本：

new接口时调用静态方法：

Lambda化格式：

原始格式：

new接口时调用非静态方法：

Lambda化格式：

原始格式：