lambda表达式

1 函数式接口

函数式接口在Java中是指：有且仅有一个抽象方法的接口。

函数式接口，即适用于函数式编程场景的接口。而Java中的函数式编程体现就是Lambda，所以函数式接口就是可 以适用于Lambda使用的接口。只有确保接口中有且仅有一个抽象方法，Java中的Lambda才能顺利地进行推导。

@FunctionalInterface可以放在接口上面，定义一个函数式接口

# 语法糖
备注：“语法糖”是指使用更加方便，但是原理不变的代码语法。例如在遍历集合时使用的for-each语法，其实 底层的实现原理仍然是迭代器，这便是“语法糖”。从应用层面来讲，Java中的Lambda可以被当做是匿名内部类的“语法糖”，但是二者在原理上是不同的。

2 语法格式

(o1,o2) -> Integer.compare(o1,o2);

• ->是Lambda操作符或箭头操作符

• ->左边是Lambda形参列表（其实就是接口中的抽象方法的形参列表）

• ->右边是lambda体（Lambda 表达式要执行的功能/重写的接口的方法）

3 代码演示

定义六个接口

public interface ILambdaInterface {
}
//无参无返回值
interface NoReturnNoParam{
   void m1();
}
//一个参数无返回值
interface  NoReturnOneParam{
    void m1(int a);
}
//多个参数无返回值
interface NoReturnParam{
    void m1(int a,int b);
}
//无参有返回值
interface ReturnNoParam{
    int m1();
}
//一个参数有返回值
interface ReturnOneParam{
    int m1(int a);
}
//多个参数有返回值
interface ReturnParam{
    int m1(int a ,int b);
}

用lambda表达式实现

public class LambdaTest {
    public static void main(String[] args) {
        //无参无返回值
        NoReturnNoParam noReturnNoParam = () -> {
            System.out.println(1);
        };
        noReturnNoParam.m1();
        //一个参数无返回值
        NoReturnOneParam noReturnOneParam=(int a) -> {
            System.out.println(a);
        };
        noReturnOneParam.m1(5);
        //多个参数无返回值
        NoReturnParam noReturnParam =(int a ,int b) ->{
            System.out.println(a+b);
        } ;
        noReturnParam.m1(5,10);
        //无参有返回值
        ReturnNoParam returnNoParam =() -> {
            System.out.println(100);
            return 100;
        };
        System.out.println(returnNoParam.m1());
        //一个参数有返回值
        ReturnOneParam returnOneParam = (int a) ->{
            return a;
        };
        System.out.println(returnOneParam.m1(10));
        //多个参数有返回值
        ReturnParam returnParam= (int a, int b)-> {
            return a+b;
        };
        System.out.println(returnParam.m1(10, 90));
    }
}

4 简化lambda表达式

• 可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。

• 可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。

• 可选的大括号：如果主体包含了一个语句，就不需要使用大括号。

• 可选的返回关键字：如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定表达式返回了一个数值。

简化后：

public class LambdaTest01 {
    public static void main(String[] args) {
        //lambda表达式简化
        NoReturnParam noReturnParam =(int a ,int b) ->{
            System.out.println(a+b);
        } ;
        noReturnParam.m1(5,95);
        
        
        //不需要声明参数类型，编译器可以统一识别参数值。
        NoReturnParam noReturnParam1 =( a , b) ->{
            System.out.println(a+b);
        } ;
        noReturnParam1.m1(5,95);
        System.out.println("=====================================");
        NoReturnOneParam noReturnOneParam=(int a) -> {
            System.out.println(a);
        };
        noReturnOneParam.m1(5);
        
        
        //一个参数无需定义圆括号，但多个参数需要定义圆括号。
        NoReturnOneParam noReturnOneParam1= a ->{
            System.out.println(a);
        };
        noReturnOneParam1.m1(666);
        System.out.println("=======================================");
        NoReturnNoParam noReturnNoParam = () -> {
            System.out.println(1);
        };
        noReturnNoParam.m1();
        
        
        //如果主体包含了一个语句，就不需要使用大括号。
        NoReturnNoParam noReturnNoParam1 = ()->System.out.println("lambda");
        noReturnNoParam1.m1();
        ReturnOneParam returnOneParam = (int a) ->{
            return a;
        };
        System.out.println(returnOneParam.m1(10));
        
        
        //如果主体只有一个表达式返回值则编译器会自动返回值，大括号需要指定表达式返回了一个数值。
        ReturnOneParam returnOneParam1 = a -> a;
        System.out.println(returnOneParam1.m1(10));
    }
}

5 变量作用域

访问局部变量要注意如下 3 点：

• 可以直接在 Lambda 表达式中访问外层的局部变量；

• 在 Lambda 表达式当中被引用的变量的值不可以被更改；（本质上因为lambda用的是内部类）

• 在 Lambda 表达式当中不允许声明一个与局部变量同名的参数(包括参数的名称也不能一样)

# 补充内部类应用的变量为什么是常量

因为局部内部类是相当于拷贝一份局部变量的值，如果局部变量的值可以随便的改变，那么可能会造成结果的不一致性，所以局部变量必须定义成常量。

从生命周期上来看，内部类运行期间可能会使用局部变量的值的时间超过内部类的存在时间，若局部变量的值不是final类型，则会出现引用非法。（线程使用）

6.四大内置核心函数式接口

内置接口：Cousumer<T>、Supplier<T>、Function<T R>、Predicate<T>

• Supplier<T>

/*
       Supplier<T>{ 供给型接口 Supplier, 无参数,返回一个 T 类型的返回值
           T get();
         }
     */
// Supplier  生产者
Supplier<Integer> supplier = () -> new Random().nextInt(100);
Integer integer = supplier.get();
System.out.println(integer);

• Consumer<T>

     /*
        Consumer<T> {  消费性接口 Consumer, 接收一个 T 类型的参数,无返回值
            void accept(T t);
        }
    */

// Consumer 消费者
Consumer<Integer> consumer = (money) -> System.out.println("今晚潇洒花费" + money + "元");
consumer.accept(1000);

• Function<T R>

    /* 
        Function<T R>{ 函数型接口 Function, 接收一个 T 类型的参数,返回一个 R 类型的返回值
               R apply(T t);
           }
     */
//Function 类型转换
Function<Dog, Integer> function = (dg) -> dg.getAge();
Integer i = function.apply(new Dog("渔多", 22));
System.out.println(i);

ArrayList<Dog> dogs = new ArrayList<>();
Collections.addAll(dogs, new Dog("a", 1), new Dog("b", 2), new Dog("c", 3), new Dog("d", 4));
Function<List<Dog>, HashMap<String, Integer>> function1 = (dd) -> {
    HashMap<String, Integer> map = new HashMap<>();
    for (Dog dog : dd) {
        map.put(dog.getName(), dog.getAge());
    }
    return map;
};
HashMap<String, Integer> apply = function1.apply(dogs);
System.out.println(apply);

• Predicate<T>

	/*
    Predicate<T t>{ 断言型接口 Predicate, 接收一个 T 类型的参数,返回一个 boolean 类型的返回值
        boolean test(T t);
    }
    */

 // Predicate 预言
Predicate<String> predicate = (str) -> {
    char[] chars = str.toCharArray();
    for (char aChar : chars) {
        if (!Character.isDigit(aChar)) {
            return false;
        }
    }
    return true;
};
System.out.println(predicate.test("abc"));
System.out.println(predicate.test("123"));

7 方法引用

双冒号:: 为引用运算符，而它所在的表达式被称为方法引用。如果Lambda要表达的函数方案已经存在于某个方法的实现中，那么则可以通过双冒号来引用该方法作为Lambda的替代者。

1 构造方法引用

格式：类名::new

注意需要调用构造器的参数列表要与函数式接口中抽象方法的参数列表一致，可以是一个参数，也可以是多个参数。

符合 （方法参数）->new 对象（构造参数） 这样的类型，就可以使用 对象::new ， 如果是有参的构造，参数由方法参数决定。

# 前提条件
    1 抽象方法中，创建对象
    2 抽象方法的参数要和构造方法参数一致

public class Person {
    int id;
    String name;
    int age;

    public Person() {
    }
    public Person(String name){
        this.name=name;
    }

    public Person(int id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }
    // set  get  toString
}

2 静态方法引用

格式： 类名::静态方法名

本质上要求： 接口中的方法调用了另一个类的静态方法。要求两个方法的参数要一致。

@FunctionalInterface
public interface InterA {

    Integer toInt(String s);
}

public class StaticB {
    public static Integer parse(String s){
        return Integer.valueOf(s);
    }
}

3 实例方法引用

格式： 对象名::方法名

本质上要求： 接口的方法调用了对象的方法。要求两个方法的参数要一致。

public interface InterB {

    String p(Integer x);
}

public class MyClass {
    public String parse(Integer i){
        return String.valueOf(i);
    }
}

4 对象方法引用

格式： 类名::方法名

条件：在抽象方法中，参数作为实例方法调用者，就可以简化

@FunctionalInterface
public interface InterC {
    boolean empty(String s);

}