Java中Lambda表达式的使用

前言

Lambda表达式是在Java 8的时候添加的，引入了函数式接口的概念。Lambda表达式免去了使用匿名方法的麻烦，使用Lambda会让代码变得跟简洁紧凑。

Lambda的基础使用

1.Lambda表达式的结构

public class Program {
    public static void main(String[] args) {
        /*
        Lambda分为3部分
        ():参数列表
        ->:Lambda表达式运算符
        {}:方法体 写具体操作
         */
        Lam lam = (int a, int b) -> {return a + b;};
        System.out.println(lam.add(2,4));//6
    }

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

2.函数式的参数和返回值不同 有不同Lambda表达式的写法

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

        /*
        方法体只有一条语句的话，花括号可以省略
        If1 if1 = () -> System.out.println("无参数无返回值");
         */
        If1 if1 = () -> {
            System.out.println("无参数无返回值");
        };
        if1.test();

        /*
        只有一个参数的话，小括号可以省略
        If2 if2 =a-> {
            System.out.println("a = " + a);
        };
         */
        //单个参数无返回值
        If2 if2 = (int a) -> {
            System.out.println("a = " + a);
        };
        if2.test(6);

        /*
        参数列表的参数类型可以省略，省略的话就要全部都省略
        //两个参数无返回值
        If3 if3 = (a,b) -> {
            System.out.println("a = " + a + "||b = " + b);
        };
         */
        //两个参数无返回值
        If3 if3 = (int a,int b) -> {
            System.out.println("a = " + a + "||b = " + b);
        };
        if3.test(2,4);

        /*
        如果方法体中只有一条语句并且是return语句，那样省略大括号的同时return也是省略
        If4 if4 = () -> 1;
         */
        //无参数有返回值
        If4 if4 = () -> {
            return 1;
        };
        System.out.println(if4.test());

        //单个参数有返回值
        If5 if5 = (int a) -> {
            return a;
        };
        System.out.println(if5.test(888));

        //两个参数有返回值
        If6 if6 = (int a,int b) -> {
            return a + b;
        };
        System.out.println(if6.test(4,5));
    }
}

interface If1{
    //无参数无返回值
    void test();
}

interface If2{
    //单个参数无返回值
    void test(int a);
}

interface If3{
    //两个参数无返回值
    void test(int a,int b);
}

interface If4{
    //无参数有返回值
    int test();
}

interface If5{
    //单个参数有返回值
    int test(int a);
}

interface If6{
    //两个参数有返回值
    int test(int a,int b);
}

3.Lambda封装成方法引用

public class LambdaTest02 {
    public static void main(String[] args) {
        /*
        If5 if5 = a -> a*2;
         */
        /*
        方法引用：如果多个lambda表达式实现函数是一样的话，我们可以封装成通用方法
        方法引用的语法:
        对象 :: 方法    例(lambdaTest02 :: testA)
        静态方法可以直接 类名 :: 方法 例(LambdaTest02::testB)
         */

        LambdaTest02 lambdaTest02 = new LambdaTest02();
        If8 if8 = lambdaTest02 :: testA;
        System.out.println(if8.test(8));

        If8 if88 = LambdaTest02::testB;
        System.out.println(if88.test(8));
    }
    public int testA(int a){
        return a * 2;
    }

    public static int testB(int a){
        return a * 2;
    }

}

interface If8{
    //单个参数有返回值
    int test(int a);
}

4.lambda表达式的构造方法引用

public class LambdaTest03 {
    public static void main(String[] args) {
//      DogService1 dogService1 = () -> new Dog();
//      System.out.println(dogService1.getDog());

        /*
        如果lambda表达式的实现刚好可以通过调用一个类的构造方法来实现
        那么就可以使用构造方法引用，语法是 类名::new
         */
        DogService1 dogService1 = Dog::new;
        System.out.println(dogService1.getDog());

        DogService2 dogService2 = Dog::new;
        System.out.println(dogService2.getDog("小黄",3));
    }
}

interface DogService1{
    Dog getDog();
}

interface DogService2{
    Dog getDog(String name,int age);
}

public class Dog {
    private String name;

    private int age;

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

    public Dog(String name, int age) {
        System.out.println("有参构造方法");
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

5.@Functionallnterface注解

函数式接口：有且仅有一个抽象方法的接口。使用Lambda表达式创建一个函数式接口的对象，一定要确保接口中有且仅有一个抽象方法，Lambda才能顺利的运行。
@Functionallnterface该注解用于一个接口的定义上，一旦使用该注解来定义接口，编译器将会强制检查该接口是否有且仅有一个抽象方法(equal和hashcode方法不算),否则将会报错。这个注解并不是必须的，只要符合函数式接口的定义，那么这个接口就是函数式接口。