Java 基础（二）| 使用 lambad 表达式的正确姿式

时间  2020-01-18
标签 java 基础 使用 lambad 表达式 正确 栏目 Java 繁體版
原文   原文链接

Lambda表达式

前言

为跳槽面试作准备，今天开始进入 Java 基础的复习。但愿基础很差的同窗看完这篇文章，能掌握 lambda 表达式，而基础好的同窗权当复习，但愿看完这篇文章可以起一点你的青涩记忆。html

1、什么是 lambda 表达式

Java8 是咱们使用最普遍的稳定 Java 版本，lambda 就是其中最引人瞩目的新特性。lambda 是一种闭包，它容许把函数当作参数来使用，是面向函数式编程的思想，能够使代码看起来更加简洁。是否是听得一脸懵逼？我举个栗子你就明白了。前端

烂掉牙的例子，在没有 lambda 时候，咱们是这样写的：java

// 内部类写法
public class InnerClassMain {
    public static void main(String[] args) {
        //匿名内部类写法
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("内部类写法");
            }
        }).start();
    }
}
复制代码

有 lambda 以后，咱们就用 lambda 写：python

// lambda 写法
public class LambdaMain {
    
    public static void main(String[] args) {
        //lambda 写法
        new Thread(() -> System.out.println("lambda写法")).start();
    }
    
}
复制代码

咱们应该知道，实现线程有两种方法，一是继承 Thread 类，二是实现 Runnable 接口。那这里采用的就是后者，后者是一个函数式接口。linux

1.1 函数式接口

@FunctionalInterface
public interface Runnable {
    /** * When an object implementing interface <code>Runnable</code> is used * to create a thread, starting the thread causes the object's * <code>run</code> method to be called in that separately executing * thread. * <p> * The general contract of the method <code>run</code> is that it may * take any action whatsoever. * * @see java.lang.Thread#run() */
    public abstract void run();
}
复制代码

从 Runnable 源码能够看到，它是一个**函数式接口。**这类接口的特色是：用 @FunctionalInterface 注解修饰（主要用于编译级错误检查，加上该注解，当你写的接口不符合函数式接口定义的时候，编译器会报错），有且只有一个抽象方法。在原生 JDk 中的这类接口就能够使用 lambda 表达式。c++

上面的概念提到，把函数当作参数来使用。上面的 lambda 例子中，Thread 类的参数就是一个 Runnable 接口，lambda 就是实现这个接口并把它当作参数使用。因此上面的 () -> System.out.println("lambda写法") 就是一个整个 lambda 表达式的参数（注意与后面的方法参数区分开，后面会讲）。细品加粗这句话，能够总结出，**lambda 表达式就是建立某个类的函数式接口的实例对象。**如：git

Runnable runnable = () -> System.out.println("lambda写法");
复制代码

2、为何须要 lambda 表达式

明白了什么是 lambda 表达式，那为何要使用它呢？注意到使用 lambda 建立线程的时候，咱们并不关心接口名，方法名，参数名。咱们只关注他的参数类型，参数个数，返回值。因此缘由就是简化代码，提升可读性。github

3、如何使用 lambda表达式

3.1 lambda 语法

// 格式遵循: (接口参数)->表达式(具体实现的方法)
(paramters) -> expression 或 (parameters) ->{ expressions; }
复制代码

lambda 语法例子

具体解释，如上图。此外，lambda 语法注意点：面试

  • 可选类型声明：方法参数不须要声明参数类型，编译器能够统一识别参数值。
  • 可选的参数圆括号：一个参数无需定义圆括号，但无参数或多个参数须要定义圆括号。
  • 可选的大括号：若是具体实现方法只有一个语句，就不须要使用中括号{}。
  • 可选的返回关键字：若是具体实现方法只有一个表达式，则编译器会自动返回值，若是有多个表达式则，中括号须要指定明表达式返回了一个数值。

使用示例：算法

public class Example {

    // 定义函数式接口，只能有一个抽象接口，不然会报错
    // 但愿在编译期检出报错，请加 @FunctionalInterface 注解
    public interface Hello {
        String hi();
    }

    public interface Hello2 {
        String hei(String hello);
    }

    public interface Hello3 {
        String greet(String hello, String name);
    }

    public static void main(String[] args) {

        // 入参为空
        Hello no_param = () -> "hi, no param";
        Hello no_param2 = () -> {
            return "hi, no param";
        };

        System.out.println(no_param.hi());
        System.out.println(no_param2.hi());

        // 单个参数,一条返回语句,能够省略大括号和 return
        Hello2 param = name -> name;
        Hello2 param2 = name -> {
            return name;
        };

        // 打印
        System.out.println(param.hei("hei, 一个优秀的废人"));
        System.out.println(param2.hei("hei, 一个优秀的废人"));

        // 多个参数
        Hello3 multiple = (String hello, String name) -> hello + " " + name;

        // 一条返回语句，能够省略大括号和 return
        Hello3 multiple2 = (hello, name) -> hello + name;

        // 多条处理语句，须要大括号和 return
        Hello3 multiple3 = (hello, name) -> {
            System.out.println(" 进入内部 ");
            return hello + name;
        };

        // 打印
        System.out.println(multiple.greet("hello,", "祝2020脱单"));
        System.out.println(multiple2.greet("hello,", "祝2020脱单"));
        System.out.println(multiple3.greet("hello,", "祝2020脱单"));
    }
}
复制代码

3.3 方法引用

看一个简单的方法引用例子：

Consumer<String> sc = System.out::println;
sc.accept("一个优秀的废人");

// 等效于
Consumer<String> sc2 = (x) -> System.out.println(x);
sc2.accept("一个优秀的废人");
复制代码

Consumer 函数式接口源码：

@FunctionalInterface
public interface Consumer<T> {
    void accept(T t);
}
复制代码

你可能有点懵，为何能够这样写？别急咱们分析一波：Consumer 是一个函数式接口，抽象方法是 void accept(T t)，参数都是 T。那咱们如今有这样一个需求，我想利用这个接口的抽象方法，作一下控制台打印。正常状况下，咱们须要实现这个接口，实现它的抽象方法，来实现这个需求：

public class ConsumerImpl implements Consumer<String> {
    @Override
    public void accept(String s) {
        System.out.println(s);
    }
}
复制代码

实现以后，这个抽象方法变具体了。做用就是控制台打印，那就意味着抽象方法恰好能够用实际方法： System.out.println(s) 来实现，因此咱们能够使用方法引用。

总结：函数式接口的抽象方法实现刚好能够经过调用一个实际方法来实现时，就能够用方法引用。

方法引用的三种形式：

// 将抽象方法参数当作实际方法的参数使用
对象：：实例方法 objectName::instanceMethod
// 将抽象方法参数当作实际方法的参数使用
类：：静态方法 ClassName::staticMethod
// 将方法参数的第一个参数当作方法的调用者，其余的参数做为方法的参数
类：：实例方法  ClassName::instanceMethod 
复制代码

自定义一个方法类：

public class Method {
    // 静态方法
    public static void StaticMethod(String name) {
        System.out.println(name);
    }

    // 实例方法
    public void InstanceMethod(String name) {
        System.out.println(name);
    }

    // 无参构造方法
    public Method() {
    }

    // 有参数构造
    public Method(String methodName) {
        System.out.println(methodName);
    }
}
复制代码

测试用例：

public class MethodExample {

    public static void main(String[] args) {

        // 静态方法引用--经过类名调用
        Consumer<String> consumerStatic = Method::StaticMethod;
        consumerStatic.accept("静态方法");
        // 等价于
        Consumer<String> consumerStatic2 = (x) -> Method.StaticMethod(x);
        consumerStatic2.accept("静态方法");

        System.out.println("--------------------------");
        //非静态方法引用--经过实例调用
        Method method = new Method();
        Consumer<String> consumerInstance = method::InstanceMethod;
        consumerInstance.accept("对象的实例方法");
        // 等价于
        Consumer<String> consumerInstance2 = (x) -> method.InstanceMethod(x);
        consumerInstance2.accept("对象的实例方法");

        System.out.println("--------------------------");
        //ClassName::instanceMethod 类的实例方法：把表达式的第一个参数当成 instanceMethod 的调用者，其余参数做为该方法的参数
        BiPredicate<String, String> sbp = String::equals;
        System.out.println("类的实例方法 " + sbp.test("a", "A"));
        // 等效
        BiPredicate<String, String> sbp2 = (x, y) -> x.equals(y);
        System.out.println("类的实例方法 " + sbp2.test("a", "A"));
    }
}
复制代码

输出结果：

静态方法
静态方法
--------------------------
对象的实例方法
对象的实例方法
--------------------------
类的实例方法false
类的实例方法false
复制代码

3.4 构造器引用

public class ConstructMethodExample {

    public static void main(String [] args) {
        // 构造方法方法引用--无参数(能够使用方法引用)
        Supplier<Method> supplier = Method::new;
        System.out.println(supplier.get());
        // 等价于
        Supplier<Method> supplier2 = () -> new Method();
        System.out.println(supplier2.get());

        // 构造方法方法引用--有参数
        Function<String, Method> uf = name -> new Method(name);
        Method method = uf.apply("一个优秀的废人");
        System.out.println(method.toString());
    }

}
复制代码

3.5 变量做用域

lambda 表达式只能引用标记了 final 的外层局部变量，这就是说不能在 lambda 内部修改定义在域外的局部变量，不然会编译错误。

public class VariableScopeTest {

    // 定义一个接口
    public interface Converter<T1, T2> {
        void convert(int i);
    }
    
    public static void main(String [] args) {

        // 定义为 final 强制不能修改
        final int num = 1;
        Converter<Integer, String> s = (param) -> System.out.println(String.valueOf(param + num));
        // 输出结果为 3
        s.convert(2);  
    }

}
复制代码

变量不声明为 final ，致使能够修改外部变量报错：

int num = 1；
Converter<Integer, String> s = (param) -> System.out.println(String.valueOf(param + num));
s.convert(2);
复制代码

此外，在 Lambda 表达式当中不容许声明一个与局部变量同名的参数或者局部变量

String first = "";  
// 同为 first 变量名，编译会出错 
Comparator<String> comparator = (first, second) -> Integer.compare(first.length(), second.length());  
复制代码

4、十大 lambda 表达式示例

Github源码地址：github.com/turoDog/rev…

最后

若是看到这里，喜欢这篇文章的话，帮忙 " 转发 "或者点个" 在看 "，行吗？祝大家 2020 暴富。微信搜索「一个优秀的废人」，欢迎关注。

回复「1024」送你一套完整的 java、python、c++、go、前端、linux、算法、大数据、人工智能、小程序以及英语教程。

回复「电子书」送你 50+ 本 java 电子书。

最全教程
相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程