【Lambda表达式】_JAVA

当程序员越来越懒时，就出现了Lambda表达式~

Lambda表达式为何会TM出现？

1、避免匿名内部类定义过多
2、你既懒了，代码也整洁了
3、去掉了一堆无意义的代码，只留下核心逻辑代码

函数式接口

1、任何接口，若只包含唯一一个抽象方法，则该接口即为函数式接口
2、对于函数式接口，可通过Lambda表达式来实例化该接口

public interface Runnable {
    public abstract void run(); // 可不写abstract关键字，会隐式声明成abstract
}

总结：

老规矩，总结写前头
1、若接口中的抽象方法只有一个形参，则Lambda表达式中可将参数类型和包裹形参的()都省略
2、若接口中的抽象方法形参有多个，则Lambda表达式中参数类型要么全省略，要么都不省略，但是，不论参数类型省略与否，包裹形参的()都不能省略
3、若接口中的抽象方法，其方法体实现只有一行代码，则Lambda表达式中，可将包裹代码块的{}省略，否则不可省略

好了，看到这里，说明你还想了解Lambda表达式的真实面貌，答应我，请继续往下撸~

Lambda表达式推导

外部类实现 函数式接口

public class LambdaExpression {
    public static void main(String[] args) {
        FuncInterface impClass = new ImpClass();
        impClass.func();
    }
}

// 1.定义函数式接口
interface FuncInterface{
    void func();
}

// 2.实现函数式接口中的抽象方法
class ImpClass implements FuncInterface{
    @Override
    public void func() { System.out.println("实现接口中的抽象方法"); }
}

将外部类 替换为 静态内部类

public class LambdaExpression {

    // 3.将外部类 变成 静态内部类
    static class ImpClass implements FuncInterface{
        @Override
        public void func() { System.out.println("实现接口中的抽象方法"); }
    }

    public static void main(String[] args) {
        FuncInterface impClass = new ImpClass();
        impClass.func();
    }
}

// 1.定义函数式接口
interface FuncInterface{
    void func();
}

将静态内部类 替换为 局部内部类

public class LambdaExpression {
    public static void main(String[] args) {
        // 4.局部内部类
        class ImpClass implements FuncInterface{
            @Override
            public void func() { System.out.println("实现接口中的抽象方法"); }
        }
        
        FuncInterface impClass = new ImpClass();
        impClass.func();
    }
}

// 1.定义函数式接口
interface FuncInterface{
    void func();
}

将局部内部类 替换为 匿名内部类

public class LambdaExpression {
    public static void main(String[] args) {

        // 5.匿名内部类：没有类名，只能借助接口或父类
        FuncInterface funcInterface = new FuncInterface() {
            @Override
            public void func() { System.out.println("实现接口中的抽象方法"); }
        };
        funcInterface.func();

    }
}

// 1.定义函数式接口
interface FuncInterface{
    void func();
}

将匿名类 替换为 Lambda表达式

上帝想了想，函数式接口反正就一个抽象函数，干脆把父类或接口 及 接口中重写的方法名 给删除得了，因此就有了下面的Lambda表达式
()->{ // 重写方法的方法体实现 }; // 大佬们可得注意，这最后可是有一个分号的

public class LambdaExpression {
    public static void main(String[] args) {
        // 6.Lambda表达式：去掉接口 及 抽象方法的方法名，只留下实现体并加上->
        FuncInterface funcInterface = ()-> { System.out.println("实现接口中的抽象方法"); };
        funcInterface.func();
    }
}

// 1.定义函数式接口
interface FuncInterface{
    void func();
}

兄弟，到这了，你以为你就已经掌握Lambda表达式了？ 想多了，接着往下看吧您嘞~

对于带参数的Lambda表达式，可如下简化：

省略参数类型 及 括号

// 带参数类型
public class LambdaExpression {
    public static void main(String[] args) {
        FuncInterface funcInterface = (int a)->{
            System.out.println("实现接口中的抽象方法" + a);
        };
        funcInterface.func(3);
    }
}

// 1.定义函数式接口
interface FuncInterface{
    void func(int a);
}

public class LambdaExpression {
    public static void main(String[] args) {
        FuncInterface funcInterface = a->{
            System.out.println("实现接口中的抽象方法" + a);
        };
        funcInterface.func(3);
    }
}

// 1.定义函数式接口
interface FuncInterface{
    void func(int a);
}

好了，到此为止，Lambda表达式你已经入门了，接下来就是终极大招了

1.若接口中的抽象方法，其实现体只有一行代码，则可将包裹代码块的{}省略

public class LambdaExpression {
    public static void main(String[] args) {
        FuncInterface funcInterface = a->
            System.out.println("实现接口中的抽象方法" + a);
        funcInterface.func(3);
    }
}

// 1.定义函数式接口
interface FuncInterface{
    void func(int a);
}

2.若抽象接口中的抽象方法，有多个形参，则多个形参可都省略掉参数类型，但：a：所有形参要么全部省略掉参数类型，要么都不省略；b：多个形参省略掉参数类型后，必须加上()

public class LambdaExpression {
    public static void main(String[] args) {
        FuncInterface funcInterface = (a, b)->
            System.out.println("实现接口中的抽象方法" + a + ", " + b);
        funcInterface.func(3, 5);
    }
}

// 1.定义函数式接口
interface FuncInterface{
    void func(int a, int b);
}