【Java基础】Lambda表达式

1. 函数式接口

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

2. 为什么使用Lambda内部类？

• 避免匿名内部类定义过多。
• 去掉一堆没有意义的代码，只留下核心的逻辑，让代码看起来更简洁。

Lambda表达式实质属于函数式编程的概念。

(params) -> expression [表达式]
(params) -> statement [语句]
(params) -> {statements}

3. Lambda表达式的演化过程

3.1 实现类

正常情况下，我们是使用实现类来做。

public class TestLambda1 {
    public static void main(String[] args) {
        ILike like = new Like();
        like.lambda();
    }
}

//1. 定义一个函数式接口
interface ILike {
    void lambda();
}

//2. 实现类
class Like implements ILike {
    @Override
    public void lambda() {
        System.out.println("I like Lambda!");
    }
}

执行结果：

I like Lambda!

3.2 静态内部类

但是，实现类Like 在 类TestLambda1 的外面，不够简洁，我们想到静态内部类。

public class TestLambda1 {

    //2. 静态内部类
    static class Like implements ILike{
        @Override
        public void lambda() {
            System.out.println("I like Lambda2!");
        }
    }

    public static void main(String[] args) {
        ILike like = new Like();
        like.lambda();
    }
}

//1. 定义一个函数式接口
interface ILike {
    void lambda();
}

执行结果：

I like Lambda2!

3.3 局部内部类

静态内部类还是太繁琐了，于是我们想到局部内部类。

public class TestLambda1 {

    public static void main(String[] args) {
        //2. 局部内部类
        class Like implements ILike{
            @Override
            public void lambda() {
                System.out.println("I like Lambda3!");
            }
        }

        ILike like = new Like();
        like.lambda();
    }
}

//1. 定义一个函数式接口
interface ILike {
    void lambda();
}

执行结果：

I like Lambda3!

3.4 匿名内部类

还能再怎么简化呢？我们想到了匿名内部类。

public class TestLambda1 {

    public static void main(String[] args) {
        //2. 匿名内部类：没有类的名称，必须借助接口或者父类
        ILike like = new ILike(){
            @Override
            public void lambda() {
                System.out.println("I like Lambda4!");
            }
        };

        like.lambda();
    }
}

//1. 定义一个函数式接口
interface ILike {
    void lambda();
}

执行结果：

I like Lambda4!

3.5 Lambda表达式

既然都匿名内部类了，干脆再简洁点，于是Lambda表达式来了。

因为函数式接口里面只有一个方法，所以我们只保留这个方法的参数和方法体，并且参数(params)和方法体{...}之间用 ->连接起来。具体使用示例如下：

public class TestLambda1 {

    public static void main(String[] args) {
        //2. 用Lambda简化
        ILike like = () -> {
            System.out.println("I like Lambda5!");
        };

        like.lambda();
    }
}

//1. 定义一个函数式接口
interface ILike {
    void lambda();
}

执行结果：

I like Lambda5!

再举一个Lambda表达式的应用示例：

public class TestLambda2 {
    public static void main(String[] args) {
    
        //1. lambda表达式
        ILove love1 = (int a) -> {
            System.out.println("I love ----> " + a);
        };
        love1.love(1);

        //2.简化方式1: 去掉参数类型，如果是多个参数时，要去掉就要全部去掉
        ILove love2 = (a) ->{
                System.out.println("I love ----> " + a);
        };
        love2.love(2);

        //3. 简化方式2: 当参数只有一个时，可以去掉括号
        ILove love3 = a ->{
            System.out.println("I love ----> " + a);
        };
        love3.love(3);

        //4. 简化方式3: 当代码只有一行时，可以去掉花括号
        ILove love4 = a -> System.out.println("I love ----> " + a);
        love3.love(4);

    }
}

interface ILove{
    void love(int a);
}

执行结果：

I love ----> 1
I love ----> 2
I love ----> 3
I love ----> 4