java lambda表达式知识点总结

lambda本质是一个匿名方法，可以让你的方法变得更简洁

lambda表达式结构

参数列表 方法体

() 参数列表

{} 方法体

-> lambda 运算符

一般的java方法是这样的

int add(int a, int b){
return a + b;
}

用lambda表达式可以这样表示

(int a,int b) ->{return a+b;};

lambda基础语法

public class Program1 {

    interface LambdaLearn{
        int add(int a, int b);
    }

    public static void main(String[] args) {
        LambdaLearn lambdaLearn = (int a, int b) -> {return a + b;};
        System.out.println(lambdaLearn.add(1, 2));
    }

}

lambda语法精简

1.参数类型：

由于在接囗的抽象方法中，已经定义了参数的数量和类型。所以在lambda表达式中，参数的类型可以省略。

如果需要省略参数则每一个参数的类型都要省略．干万不要出现省略一个参数类型，不省略一个参数类型

2.参小括号：

如果参数列表中，参数的数量只有一个，此时小括号可以省略

3.方法大括号：

如果方法体中只有一条语句，此时大括号可以省略

如果方法体中唯一的一条语句是一个返回语句，则在省掉大括号的同时，也必须省路掉return.

public class Program1 {
    interface LambdaLearn{
        int add(int a, int b);
    }

    public static void main(String[] args) {
        LambdaLearn lambdaLearn = (int a, int b) -> {return a + b;};
        System.out.println(lambdaLearn.add(1, 2));

        //精简语法后的lambda表达式
        LambdaLearn lambdaLearn2 = (a, b) -> a + b;
        System.out.println(lambdaLearn2.add(1, 2));
    }
}

lambda方法引用

如果lambda表达式中的方法体逻辑过多，建议另外写一个方法，在lambda中调用该方法

public class Program2 {
    interface LambdaLearn{
        int add(int a, int b);
    }

    public static void main(String[] args) {
        //调用静态方法
        LambdaLearn lambdaLearn = (a, b) -> test(a ,b);
        LambdaLearn lambdaLearn11 = Program2::test;//简化写法
        //调用非静态方法
        LambdaLearn lambdaLearn2 = (a, b) -> new Program2().test2(a ,b);
        LambdaLearn lambdaLearn3 = new Program2()::test2;//简化写法

        System.out.println(lambdaLearn3.add(3 ,3));
    }

    static int test(int a, int b){
        if(a > b){
            return a - b;
        }
        if(a < b){
            return b -a;
        }
        return a + b;
    }

    int test2(int a, int b){
        if(a > b){
            return a - b;
        }
        if(a < b){
            return b -a;
        }
        return a + b;
    }

}

lambda构造方法引用

public class Dog {
    private String name;

    public Dog() {
        System.out.println("调用无参构造方法");
    }

    public Dog(String name) {
        this.name = name;
        System.out.println("调用有参数的构造方法:" + name);
    }

    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
}

public class Program3 {

    interface LambdaLearn{
        Dog getInsten();
    }

    interface LambdaLearn2{
        Dog getInsten2(String name);
    }
    public static void main(String[] args) {
        LambdaLearn lambdaLearn = Dog:: new;
        Dog dog = lambdaLearn.getInsten();
        LambdaLearn2 lambdaLearn2 = Dog:: new;
        Dog dog2 = lambdaLearn2.getInsten2("大黄");
    }
}

使用lambda表达式集合遍历

public class Program4 {
    public static void main(String[] args) {
       List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        list.add(3);
        //使用增强的for循环遍历
        for(Integer item : list){
            System.out.println(item);
        }
        //使用lambda表达式遍历集合
        list.forEach(item -> {
            System.out.println(item);
        });
        //使用简化的lambda表达式遍历
        list.forEach(System.out::println);
    }
}

使用lambda表达式开启新线程

public class Program5 {
    public static void main(String[] args) {
        new Thread(() -> System.out.println("开启多线程")).start();
    }
}