Lambda表达式

1. Lambda表达式介绍

简介：Lambda 表达式是 JDK8 的一个新特性，可以避免匿名内部类定义过多，极大地优化代码结构写出更优雅的 Java 代码。JDK 也提供了大量的内置函数式接口供我们使用，使得 Lambda 表达式的运用更加方便、高效。

函数式接口：理解函数式接口是学习Lambda表达式的关键，对于任何接口，如果只包含唯一一个抽象方法，那么它就是一个函数式接口。对于函数式接口我们就可以通过Lambda表达式来创建该接口的对象。

//无参无返回函数
interface Lambda{
    void f();
}

//无参有返回函数
interface Lambda{
    int f();
}

//有参无返回函数
interface Lambda{
    void f(int a);
}

//有参有返回函数
interface Lambda{
    int f(int a);
}

//多参无返回函数
interface Lambda{
    void f(int a,int b,int c);
}

//多参有返回函数
interface Lambda{
   	int f(int a,int b,int c);
}

2. Lambda表达式推导过程

1. 定义Lambda接口，首先是定义一个普通接口实现类；其次将接口实现类采用静态内部类来实现Lambda接口；再将接口实现类采用局部内部类来实现Lambda接口；然后采用匿名内部类实现Lambda接口，由于没有类的名称必须借助接口或者父类；最后才是今天的主角在匿名内部类的基础上继续缩减代码形成最终的Lambda表达式。

interface Lambda{
    void f();
}

//1. 定义实现类
class show1 implements Lambda{

    @Override
    public void f() {
        System.out.println("I am Lambda1");
    }
}

public class Test {
    //2. 静态内部类
    static class show2 implements Lambda{

        @Override
        public void f() {
            System.out.println("I am Lambda2");
        }
    }
    public static void main(String[] args) {
        Lambda l = null;
        l = new show1();
        l.f();


        l = new show2();
        l.f();

        //3. 局部内部类
        class show3 implements Lambda{
            @Override
            public void f() {
                System.out.println("I am Lambda3");
            }
        }

        l = new show3();
        l.f();

        //4. 匿名内部类
        l = new Lambda() {
            @Override
            public void f() {
                System.out.println("I am Lambda4");
            }
        };
        l.f();


        //5. Lambda表达式
        l = ()->{
            System.out.println("我是最终的Lambda表达式!");
        };
        l.f();
    }
}

Lambda表达式是在匿名内部类的基础上代码缩减过来的，由于只有一个接口实现类同时也只有一个方法，所以类和方法都可以不用，只需要保留方法的参数括号 和 方法体即可。

3. Lambda表达式简化

interface f{
    void Lambda(int a);
}

public class TestLambda {
    public static void main(String[] args) {
        f l = null;
        l = (int a)->{
            System.out.println("I am Lambda"+a);
        };
        l.Lambda(1);
}

1. 简化参数类型，对于每个变量的参数可以不加入参数类型，所有的参数要么都不省略参数类型要么都省略参数类型。

//1. 简化参数类型
   l = (a)->{
       System.out.println("I am Lambda"+a);
   };
   l.Lambda(1);

2. 简化参数括号，单参数情况下是可以省略参数括号的，多参数情况下不能省略参数括号。

//2. 简化括号
  l = a ->{
      System.out.println("I am Lambda"+a);
  };
  l.Lambda(2);

3. 简化方法括号，对于只有一句代码的方法是可以省略大括号的，但是如果有多句代码是不可以省略的。

//3. 简化方法括号
  l = a -> System.out.println("I am Lambda"+a);
  l.Lambda(3);

总结：

• 单参数情况下可以省略参数括号，多参数情况下必须加上。
• 只有一句代码的情况下可以省略大括号，多句代码的情况下是不可以省略的。
• 所有的参数类型都可以省略，但是需要注意所有的参数要么都省略参数类型要么都不省略参数类型。

4. Lambda表达式应用

1. 自己接触过的暂时只有对于一些集合的遍历采用Lambda表达式简化，例如遍历一个HashMap的容器，性能低于entrySet。

m.forEach((key, value) -> {
	System.out.println(key + ":" + value);
});

2. 跟着网课学多线程突然来一下Lambda表达式，学完才知道Runnable接口就是只有一个run方法，所以可以使用Lambda表达式来创建线程。

new Thread(() -> {
	for (int i = 0; i < 10; i++) {
	  System.out.println("Lambda: "+i);
	}
}).start();

多余的Lambda以后遇到再补。