什么是Lambda表达式

Lambda 表达式（lambda expression）是一个匿名函数，简化我们调用匿名函数的过程。
Lambda 好处：简化我们匿名内部类的调用。
Lambda+方法引用可以使代码变得更加精简。

为什么要使用Lambda表达式

可以以非常简洁的形式调用我们的匿名函数接口。

public static void main(String[] args) {
    // 1.使用new的实现类的形式调用接口
    OrderService orderSerivce1 = new OrderSerivceImpl();
    orderSerivce1.addOrder();
    // 2.使用匿名内部接口调用
    new OrderService() {
        @Override
        public void addOrder() {
            System.out.println("使用匿名内部类的形式调用接口");
        }
    }.addOrder();
    // 3.使用lambda调用接口
    OrderService orderSerivce2=  ()-> System.out.println("使用lambda调用接口");
    orderSerivce2.addOrder();
}

Lambda表达式的规范

函数式接口：也称 SAM 接口，即 Single Abstract Method interfaces，有且只有一个抽象方法，但可以有多个非抽象方法的接口

在接口中只能够允许有一个抽象方法
在函数接口中可以定义object类中方法
可以使用默认或者静态方法
@FunctionalInterface 标记该接口为函数式接口

在 java 8 中专门有一个包放函数式接口java.util.function，该包下的所有接口都有 @FunctionalInterface 注解，提供函数式编程。

在其他包中也有函数式接口，其中一些没有@FunctionalInterface 注解，但是只要符合函数式接口的定义就是函数式接口，与是否有@FunctionalInterface注解无关，注解只是在编译时起到强制规范定义的作用。其在 Lambda 表达式中有广泛的应用。

Lambda基础语法

（）-> {}

（）—————— 参数列表
 -> —————— 分隔符
 {} —————— 方法体

精简语法：

一个参数无需定义圆括号，但多个参数需要定义圆括号
如果主体只包含了一个语句，就不需要使用大括号
如果方法体只有一条return的情况下不需要些{} 和return
不需要声明参数类型，编译器可以统一识别参数值
无参方法调用
```java @FunctionalInterface public interface AcanthopanaxInterface { void get(); }

@Test public void acanthopanaxInterfaceTest(){ // AcanthopanaxInterface acanthopanaxInterface = () -> { // System.out.println(“使用lamdba表达式调用方法”); // }; // acanthopanaxInterface.get(); ((AcanthopanaxInterface)() -> System.out.println(“使用lamdba表达式调用方法”)).get(); }

<a name="UXnow"></a>
## 带参数和返回值
```java
@FunctionalInterface
public interface YunInterface {
    String get(int i, int j);
}
    @Test
    public void YunInterfaceTest(){
        // 1.使用匿名内部类调用有参数函数方法
//        String result = new YunInterfaceTest() {
//            @Override
//            public String get(int i, int j) {
//                return i + "-" + j;
//            }
//        }.get(1, 1);
//        System.out.println(result);
        //2.使用lamdba 调用有参数函数方法
        String result = ((YunInterface) (i, j) -> {
            System.out.println("参数:" + i + "," + j);
            return i + "-" + j;
        }).get(1, 1);
        System.out.println(result);
    }
}

方法引用

方法引用可以认为是Lambda表达式的一种特殊形式，Lambda表达式可以让开发者自定义抽象方法的实现代码，方法引用则可以让开发者直接引用已存在的实现方法，作为Lambda表达式的Lambda体

方法引用的操作符是双冒号”::“

构造器引用：类名::new
静态方法引用：类名::静态方法名称
特定对象的实例方法引用：对象实例（new 对象）::方法
对象方法的特殊引用：类名:: 实例方法名称

需要遵循一个规范：

方法引用的方法参数列表、返回类型与函数式接口的参数列表、返回类型必须要保持一致

构造器引用

造器引用的语法格式为： 类名::new ，如() -> new ArrayList<String>()等价于 ArrayList<String>::new，代码示例：

@FunctionalInterface
public interface ListInterface {
    List getList();
}
 ListInterface listInterface = () -> new ArrayList<>();

等价于

ListInterface listInterface = ArrayList::new;

构造器引用适用于lambda表达式主体中仅仅调用了某个类的构造函数返回实例的场景。

静态方法引用

静态方法引用的语法格式为： 类名::静态方法名 ，如System.out::println等价于lambda表达式s -> System.out.println(s)，代码示例

public class MethodReference {
    public static void main(String[] args) {
        // 1.使用匿名内部类的形式 调用get方法
//        new MessageInterface() {
//            @Override
//            public void get() {
//                MethodReference.getMethod();
//            }
//        }.get();
        MessageInterface messageInterface2 = () -> {
            MethodReference.getStaticMethod();
        };
        messageInterface2.get();
        // 使用方法引入调用方法 必须满足：方法引入的方法必须和函数接口中的方法参数列表/返回值一定保持一致。
        MessageInterface messageInterface = MethodReference::getStaticMethod;
        messageInterface.get();
    }
    /**
     * 静态方法引入
     */
    public static void getStaticMethod() {
        System.out.println("我是 getMethod");
    }
}}
@FunctionalInterface
public interface MessageInterface {
    void get();
}

静态方法引用适用于lambda表达式主体中仅仅调用了某个类的静态方法的情形

特定对象的实例方法引用

特定对象的实例方法引用的语法格式为： 对象::实例方法名 ，示例代码

public class Test
{
    public static void main(String[] args)
    {
        Test test = new Test();
        // lambda表达式使用：
        Arrays.asList(new String[] {"a", "c", "b"}).stream().forEach(s -> test.println(s));
        // 特定对象的实例方法引用：
        Arrays.asList(new String[] {"a", "c", "b"}).stream().forEach(test::println);
    }
    public void println(String s)
    {
        System.out.println(s);
    }
}

特定对象的实例方法引用适用于lambda表达式的主体中仅仅调用了某个对象的某个实例方法的场景

如何理解System.out::println?
先看System.out.println()

public final class System {
    ...
    public final static PrintStream out = null;
    ...
}

System是java.lang里面的一个类,而out就是System里面的一个静态数据成员，而且这个成员是java.io.PrintStream类的引用,被关键字static修饰的成员可以直接通过”类名.成员名”来引用，而无需创建类的实例。所以System.out是调用了System类的静态数据成员out
println()就是java.io.PrintStream类里的一个方法，它的作用是向控制台输出信息。因为System.out是java.io.PrintStream类的实例的引用，所以可以通过 System.out.println()来调用此方法
所以
System.out::println相当于PrintStream类的实例::println

对象方法的特殊引用

也叫特定类的任意对象的方法引用
对象方法的特殊引用的语法格式为： 类名::实例方法名
如果在使用lambda表达式实现某些接口时，lambda表达式中包含了一个对象，此时方法体中直接使用这个对象调用它的某一个方法就可以完成整个逻辑。其他的参数，可以作为调用方法的参数。此时，可以对这种实现就行简化

public static void main(String[] args) {
        //如果对于这个方法的实现逻辑，是为了得到对象的name
        GetField getField = people -> people.getName();
        //对于这个方法的特殊引用
        GetField getField1 = People::getName;
        //如果对于这个方法的实现逻辑，是为了给对象的某些属性赋值
        SetField setField = (people, name) -> people.setName(name);
        //对于这个方法的特殊引用
        SetField setField1 = People::setName;
    }
    interface GetField{
        void get(People people);
    }
    interface SetField{
        void set(People people,String name);
    }

可以发现：
如果对于某个方法的实现逻辑，刚好是参数对象的某一个方法（即lambda表达式的第一个入参为实例方法的调用者，后面的入参与实例方法的入参一致），那么就可以参数对象类名::方法名引用

访问局部变量

我们可以直接在 lambda 表达式中访问外部的局部变量：

 @Test
    public void scopeTest(){
        final int num = 2;
        int result  = ((YunInterface)(i,j) ->  i+j+num).get(1,1);//4
    }

但是和匿名对象不同的是，这里的变量num可以不用声明为final，该代码同样正确：

 @Test
    public void scopeTest(){
        int num = 2;
        int result  = ((YunInterface)(i,j) ->  i+j+num).get(1,1);//4
    }

不过这里的 num 必须不可被后面的代码修改（即隐性的具有final的语义），例如下面的就无法编译：

 @Test
    public void scopeTest(){
        int num = 2;
        int result  = ((YunInterface)(i,j) ->  i+j+num).get(1,1);//4
        num=4;
    }

Lambda案例

forEach

      ArrayList<String> strings = new ArrayList<>();
        strings.add("tifa");
        strings.add("Aerith");
        strings.add("Cloud");
//        strings.forEach(new Consumer() {
//            @Override
//            public void accept(Object o) {
//                System.out.println("o:" + o);
//            }
//        });
//      strings.forEach((o) -> {
//           System.out.println(o);
//       });
        strings.forEach(System.out::println)

Lambda集合排序

@Data
public class UserEntity {
    private String name;
    private Integer age;
}
        ArrayList<UserEntity> userlists = new ArrayList<>();
        userlists.add(new UserEntity("tifa", 16));
        userlists.add(new UserEntity("Aerith", 22));
        userlists.add(new UserEntity("Cloud", 24));
//        userlists.sort(new Comparator<UserEntity>() {
//            @Override
//            public int compare(UserEntity o1, UserEntity o2) {
//                return o1.getAge() - o2.getAge();
//            }
//        });
        userlists.sort((o1, o2) ->
                o1.getAge() - o2.getAge()
        );
        userlists.forEach((Consumer) o -> System.out.println(o));

线程调用

new Thread(()-> System.out.println("我是子线程")).start();

在工作中，常常会在使用MyBatis-Plus的条件构造器时使用到Lambda

//查询
baseMapper.selectList(
        new QueryWrapper<SupplyEntity>()
                .lambda()
                .eq(SupplyEntity::getCardId, cardBasicInfoVM.getId())
                .orderByDesc(SupplyEntity::getCreateTime));
//删除
entryStatService.delete(
        new QueryWrapper<CardEntryStat>()
        .lambda()
        .eq(CardEntryStat::getShareType, shareType)
);

Lambda表达式