专栏首页用户5521492的专栏Java 基础(二)| 使用 lambad 表达式的正确姿势

Java 基础(二)| 使用 lambad 表达式的正确姿势

为跳槽面试做准备,今天开始进入 Java 基础的复习。希望基础不好的同学看完这篇文章,能掌握 lambda 表达式,而基础好的同学权当复习,希望看完这篇文章能够起一点你的青涩记忆。

一、什么是 lambda 表达式

Java8 是我们使用最广泛的稳定 Java 版本,lambda 就是其中最引人瞩目的新特性。lambda 是一种闭包,它允许把函数当做参数来使用,是面向函数式编程的思想,可以使代码看起来更加简洁。是不是听得一脸懵逼?我举个栗子你就明白了。

烂掉牙的例子,在没有 lambda 时候,我们是这样写的:

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

有 lambda 之后,我们就用 lambda 写:

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

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

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 表达式。

上面的概念提到,把函数当做参数来使用。上面的 lambda 例子中,Thread 类的参数就是一个 Runnable 接口,lambda 就是实现这个接口并把它当做参数使用。所以上面的 () -> System.out.println ("lambda 写法") 就是一个整个 lambda 表达式的参数(注意与后面的方法参数区分开,后面会讲)。细品加粗这句话,可以总结出,lambda 表达式就是创建某个类的函数式接口的实例对象。 如:

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

二、为什么需要 lambda 表达式

明白了什么是 lambda 表达式,那为什么要使用它呢?注意到使用 lambda 创建线程的时候,我们并不关心接口名,方法名,参数名。我们只关注他的参数类型,参数个数,返回值。所以原因就是简化代码,提高可读性

三、如何使用 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());
    }

}
  • 参考:https://www.cnblogs.com/kingsonfu/p/11047116.html

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

四、十大 lambda 表达式示例

  • 示例:https://blog.csdn.net/qq_37176126/article/details/81273195

五、Github 源码地址

文章出现的所有代码都上传到我的 Github 了,觉得不错。给个 Star 呗。

  • Github 源码地址:https://github.com/turoDog/review_java/tree/master/src/main/java/com/nasus/lambda

本文分享自微信公众号 - 一个优秀的废人(feiren_java),作者:nasus

原文出处及转载信息见文内详细说明,如有侵权,请联系 yunjia_community@tencent.com 删除。

原始发表时间:2020-01-01

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

我来说两句

0 条评论
登录 后参与评论

相关文章

  • Java 基础(三)| IO流之使用 File 类的正确姿势

    为跳槽面试做准备,今天开始进入 Java 基础的复习。希望基础不好的同学看完这篇文章,能掌握泛型,而基础好的同学权当复习,希望看完这篇文章能够起一点你的青涩记忆...

    一个优秀的废人
  • java | 如何让线程按顺序执行?

    本文使用了8种方法实现在多线程中让线程按顺序运行的方法,涉及到多线程中许多常用的方法,不止为了知道如何让线程按顺序运行,更是让读者对多线程的使用有更深刻的了解。...

    一个优秀的废人
  • Git 高级用法小抄

    如果你觉得 git 很迷惑人,那么这份小抄正是为你准备的!请注意我有意跳过了 git commit、git pull/push 之类的基本命令,这份小抄的主题是...

    一个优秀的废人
  • java1.8新特性之stream

    Stream字面意思是流,在java中是指一个来自数据源的元素队列并支持聚合操作,存在于java.util包中,又或者说是能应用在一组元素上一次执行的操作序列。...

    编程思录
  • 【小家java】Java之Apache Commons-Collections4使用精讲(Bag、Map、List、Set全覆盖)

    虽然JDK提供给我们的集合框架已经足够强大,基本能解决我们平时的绝大所述问题,并且效率还挺高。

    YourBatman
  • 【趣学程序】java常用类(二)

    Math类的声明: publicfinalclassMathextendsObjectMath类是与数学计算有关的类,里面的方法都是静态方法,直接使用类名来调用...

    趣学程序-shaofeer
  • Java语言

    Java分为3个体系,为JavaSE,JavaEE,JavaME,是一种面向对象的程序设计语言,记住Oracle公司收购了 Sum公司,然后Oracle公司就负...

    达达前端
  • 知识点——Java常用API

    为了解决String字符串操作导致的内存冗余,提高效率,Java中提供了StringBuffer和StringBuilder来操作字符串,并且提供了很多方法,便...

    用户7073689
  • java中如何获取一个正整数的位数?

    用户1697231
  • Java集合:整体结构

    用户2140019

扫码关注云+社区

领取腾讯云代金券