多线程06--函数式接口与Lambda表达式

引言

学习Lamda表达式就有必要学习下函数式接口，所以本文分两大部分：函数式接口、Lambda表达式，循序渐进完成从函数式接口到Lambda表达式的推导式学习。

1.函数式接口

1.1定义

"函数式接口"是JAVA8 新特性，一个有且仅有一个抽象方法，但是可以有多个非抽象方法的接口，使用@FunctionalInterface注解，如果注释@FunctionalInterface在非函数式接口或其他类型（如类）上注释，则会发生编译时错误。具有一个抽象方法的接口仍然是一个功能接口，即使我们不用@FunctionalInterface注释。

1.2常用函数式接口

函数式接口	参数类型	返回类型	用途
Consumer	T	void	对类型T参数操作，无返回结果，包含方法 void accept(T t)
Supplier	无	T	返回T类型参数，方法时 T get()
Function	T	R	对类型T参数操作，返回R类型参数，包含方法 R apply（T t）
Predicate	T	boolean	断言型接口，对类型T进行条件筛选操作，返回boolean，包含方法 boolean test（T t）

函数式接口是为了 lambda 表达式服务，函数式接口的存在是 lambda 表达式出现的前提。

2.Lambda表达式

• 传统创建线程方式

package runnable;

public class TestThread1 implements Runnable {

    @Override
    public void run() {
        System.out.println("传统方式创建线程");
    }

    //真实情况下，线程的使用一般都在别处，这里为了偷懒写在一个类里
    public static void main(String[] args) {
        TestThread1 getTicketThread = new TestThread1();
        new Thread(getTicketThread).start();
    }
}

我们需要自定义一个实现类实现Runnable接口，将实现类对象作为Thread的构造方法入参。

• 匿名内部类方式创建线程

针对上面的程序，我们发现通过实现Runnable接口方式创建线程，我们不得不写一个实现类。如果不想写怎么办，那我们可以使用匿名内部类进行改造，代码如下：

package lambda;

public class MainTest {
    public static void main(String[] args) {
        //匿名内部类
        new Thread(new Runnable() {
            @Override
            public void run() {
                System.out.println("创建线程：匿名内部类");
            }
        }).start();
    }
}

• Lambda表达式方式创建线程

上面我们发现，使用匿名内部类的方式创建，new Thread括号里的那一大坨子代码看着还是不爽，OK，那现在再用Lambda表达式改造下：

package lambda;

public class MainTest {
    public static void main(String[] args) {
        //匿名内部类
        new Thread(new Runnable() {
            @Override
            public void run() {
                //业务1
                System.out.println("创建线程：匿名内部类");
            }
        }).start();

        //Lambda方式 业务1
        new Thread(()-> System.out.println("创建线程，Lambda方式")).start();
    }
}

上面代码两种实现方式均能实现相同的效果，当然上面的实际上是简写方式，这里我们省略了大括号，如果待实现的Runnable接口实现类的run（）方法包好多行业务代码，则大括号不能省略了，代码如下：

package lambda;

public class MainTest {
    public static void main(String[] args) {
        //匿名内部类
        new Thread(new Runnable() {
            @Override
            public void run() {
                //业务1
                System.out.println("创建线程：匿名内部类");
                //业务2
                System.out.println("2222222");
            }
        }).start();

        //Lambda方式
        new Thread(()-> {
            //业务1
            System.out.println("创建线程，Lambda方式");
            //业务2
            System.out.println("2222222");
        }).start();
    }
}

 

Lambda标准格式应该如下：

(参数类型 参数名称) ‐> { 代码语句 }

由三部分组成：一些参数、一个箭头、一段代码

       说明：

              小括号内的语法与传统方法参数列表一致：无参数则留空；多个参数则用逗号分隔。

              -> 是新引入的语法格式，代表指向动作。

               大括号内的语法与传统方法体要求基本一致。

省略规则

在Lambda标准格式的基础上，使用省略写法的规则为：

1. 小括号内参数的类型可以省略；

2. 如果小括号内有且仅有一个参，则小括号可以省略；

3. 如果大括号内有且仅有一个语句，则无论是否有返回值，都可以省略大括号、return关键字及语句分号。

• 最后总结下Lambda表达式的利弊：

• 利

       减少匿名内部类的使用，减少了开发代码量，提升开发效率。

       函数式编程，可能代表未来的编程趋势

• 弊

       局限性：必须具有接口，且要求接口中有且仅有一个抽象方法，即函数式接口。

       可读性：当Lambda表达式过长，阅读起来比较费劲；同时，对于没有掌握其的同事，阅读起来也比较费劲