Lambda表达式

一、 Lambda 表达式概述

Lambda 表达式是 JDK8 的一个新特性，可以取代大部分的匿名内部类，写出更优雅的 Java 代码，尤其在集合的遍历和其他集合操作中，可以极大地优化代码结构。JDK 也提供了大量的内置函数式接口供我们使用，使得 Lambda 表达式的运用更加方便、高效。

二、Lambda 格式

lambda 表达式的语法格式如下：

(parameters) -> expression
或
(parameters) ->{ statements; }

格式说明：

1. 小括号内的语法与传统方法参数列表一致：无参数则留空；多个参数则用逗号分隔。
2. -> 是新引入的语法格式，代表指向动作。
3. 大括号内的语法与传统方法体要求基本一致。

重要特征:

1. 可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。
2. 可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。
3. 可选的大括号：如果主体包含了一个语句，就不需要使用大括号。
4. 可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定明表达式返回了一个数值。

对接口的要求：
虽然使用 Lambda 表达式可以对某些接口进行简单的实现，但并不是所有的接口都可以使用 Lambda 表达式来实现。Lambda 规定接口中只能有一个需要被实现的方法，不是规定接口中只能有一个方法

jdk 8 中有另一个新特性：default， 被 default 修饰的方法会有默认实现，不是必须被实现的方法，所以不影响 Lambda 表达式的使用。

@FunctionalInterface
修饰函数式接口的，要求接口中的抽象方法只有一个。 这个注解往往会和 lambda 表达式一起出现。下面给出四个接口来展示基础语法，后文的全部操作都利用这四个接口来进行阐述。
案例代码：

//定义四个接口
/**第一个接口：无参无返回值*/
@FunctionalInterface
public interface NoReturnNoParam {
    void method();
}
/**第二个接口：一个参数无返回*/
@FunctionalInterface
public interface NoReturnOneParam {
    void method(int a);
}
/**第三个接口：一个参数有返回值*/
@FunctionalInterface
public interface ReturnOneParam {
    int method(int a);
}
/**第四个接口：多参数无返回*/
@FunctionalInterface
public interface NoReturnMultiParam {
    void method(int a, int b);
}
//测试代码
public static void main(String[] args) {
    //第一个接口的测试
    NoReturnNoParam noReturnNoParam = () -> {
        System.out.println("第一个接口的测试结果：我是没有参数没有返回值的");
    };
    noReturnNoParam.method();
    //第二个接口的测试
    NoReturnOneParam noReturnOneParam = (int a) -> {
        System.out.println("第二个接口的测试结果：一个参数没有返回值 参数是:" + a);
    };
    noReturnOneParam.method(6);
    //第三个接口的测试
    ReturnOneParam returnOneParam = (int a) -> {
        return a+1; //参数加1
    };
    int res2 = returnOneParam.method(6);//res2的值是7
    System.out.println("第三个接口的测试结果：返回值:" + res2);
    //第四个接口的测试
    NoReturnMultiParam noReturnMultiParam = (int a, int b) -> {
        System.out.println("第四个接口的测试结果：两个参数没有返回值 参数是：" + a +"," + b);
    };
    noReturnMultiParam.method(6, 8);
}

三、 Lambda 省略格式

我们可以通过观察以下代码来完成代码的进一步简化，写出更加优雅的代码。

案例代码：

public static void main(String[] args) {  
    //1.简化参数小括号，如果只有一个参数则可以省略参数小括号
    NoReturnOneParam lambda1 = a -> {
        System.out.println("简化参数小括号");
    };
    lambda1.method(1);
    //2.简化参数类型，可以不写参数类型，但是必须所有参数都不写
    NoReturnMultiParam lamdba2 = (a, b) -> {
        System.out.println("简化参数类型");
    };
    lamdba2.method(1, 2);
    //3.简化方法体大括号，如果方法条只有一条语句，则可以省略方法体大括号
    NoReturnNoParam lambda3 = () -> System.out.println("简化方法体大括号");
    lambda3.method();
    //4.如果方法体只有一条语句，并且是 return 语句，则可以省略方法体大括号
    ReturnOneParam lambda4 = a -> a+3;
    System.out.println(lambda4.method(5));
}

四、 Lambda 常用示例

lambda 表达式创建线程：

public static void main(String[] args) {
    //创建线程，通过匿名内部类实现
     /* new Thread(){
        @Override
        public void run() {
            for (int i = 1; i <5 ; i++) {
                System.out.print(i+" ");
            }
        }
    }.start();*/
    //lamdba表达式实现上边线程创建
    new Thread(()->{
        for (int i = 1; i <5 ; i++) {
            System.out.print(i+" ");
        }
    }).start();
}

lambda 表达式遍历数字集合：

public static void main(String[] args) {  
    //ArrayList添加整数
    ArrayList<Integer> list=new ArrayList<>();
    list.add(10);
    list.add(20);
    list.add(30);
    //遍历
    for(Integer num:list){
        System.out.print(num+" ");
    }
    System.out.println();
    //通过lambda表达遍历集合
    list.forEach(e->{
        System.out.print(e+"   ");
    });
    System.out.println();
    //遍历
    list.forEach(System.out::println);
}

lambda 表达式从集合中删除学生对象：

//学生类
public class Person {
    private int id;
    private String name;

    public Person(int id, String name) {
        this.id = id;
        this.name = name;
    }
    public int getId() {
        return id;
    }
    public String getName() {
        return name;
    }
    public void setId(int id) {
        this.id = id;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public String toString() {
        return "Person{" +
                "id=" + id +
                ", name='" + name +
                '}';
    }
}
//实现代码
public static void main(String[] args) {  
    //创建集合
    ArrayList<Person> list=new ArrayList<>();
    list.add(new Person(1,"唐僧"));
    list.add(new Person(2,"孙悟空"));
    list.add(new Person(3,"猪八戒"));
    list.add(new Person(4,"沙僧"));
    //删除姓名是ls人从集合中
    /*   for(int i=0;i<list.size();i++){
            if("猪八戒".equals(list.get(i).getName())){
                list.remove(i);
            }
        }*/
    list.removeIf(e-> "猪八戒".equals(e.getName()));
    list.forEach(System.out::println);
}

五、Lambda 注意事项

1. 使用Lambda必须要有接口，并且要求接口中有且仅有一个抽象方法
2. 表达式的参数类型可以省略，且必须同时省略，或都不省略，不能只省略一个而其他的不省略。如（int a, int b）可以写成 :（a, b）->{...}。
3. 如果只有一个参数，Lambda表达式的（parameter）可以省略括号直接写参数：parameter。
4. 如果{...}代码块的语句只有一条，(1)可以省略大括号和分号： parameter -> 方法体... 。(2)如果{...}代码块里面有返回值，需要return result ，return也要省略：parameter -> result