Lamdba表达式（三）—方法引用&构造器引用&数组引用

先上结论：

  一： 方法引用的使用
   1.使用情境：当要传递给lamdba体的操作，已经有了实现的方法了，可以使用方法引用
    （说白了  也就是lamdba体的代码， 已有现有方法了， 那么就可以用现有的方法进行替换）
   2.方法引用，本质上也是lamdba表达式，而lamdba表达式作为函数式接口的实例，所以方法引用
   也是函数式接口的实例。
   3.使用格式 ： 类（或对象）：： 方法名
   4. 具体分为如下的三种情况：
      对象 ：：非静态方法
      类  ：：静态方法
      类  ：：非静态方法
   5.方法引用使用的要求：
      要求接口中的抽象方法的形参列表和返回值类型
      与方法引用的形参类表和返回值类型相同防

   二：构造器引用
        和方法引用相似， 函数式接口的抽象方法的形参列表和构造器的形参类表一致。
        抽象方法的返回值类型即为构造器所属的类的类型
   三、数组引用
         可以把数组看做是一个特殊的类，则写法与构造器引用一致

然后 通过demo进行练习：

 我们先创建两个Employee 和EmployeeData

package lamdba;

public class Employee {
    private int id;
    private String name;
    private int age;
    private double salary;

    public Employee(int id) {
        this.id = id;
        System.out.println(id);
    }

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    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;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public Employee(int id, String name, int age, double salary) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.salary = salary;
    }

    public Employee() {
    }

    public Employee(int id, String name) {
        this.id = id;
        this.name = name;
        System.out.println("id:"+id+" name:"+name);
    }
}

EmployeeData：

package lamdba;

import java.util.ArrayList;
import java.util.List;

public class EmployeeData {
    public static List<Employee> getEmployee() {
        List<Employee> list = new ArrayList<>();
        list.add(new Employee(1001, "马化腾", 34, 6000.38));
        list.add(new Employee(1002, "马云", 35, 8765.31));
        list.add(new Employee(1003, "刘强东", 33, 3000.37));
        list.add(new Employee(1004, "雷军", 26, 654654));
        list.add(new Employee(1006, "比尔盖茨", 26, 9500.32));
        list.add(new Employee(1007, "任正非", 26, 433.32));
        list.add(new Employee(1008, "扎克伯格", 35, 2500.32));
        return list;
    }
}

 练习类L:

package lamdba;

import org.junit.jupiter.api.Test;

import java.io.PrintStream;
import java.util.function.Consumer;
import java.util.function.Supplier;

/**
 * 方法引用的使用
 * 1.使用情境：当要传递给lamdba体的操作，已经有了实现的方法了，可以使用方法引用
 *  （说白了  也就是lamdba体的代码， 已有现有方法了， 那么就可以用现有的方法进行替换）
 * 2.方法引用，本质上也是lamdba表达式，而lamdba表达式作为函数式接口的实例，所以方法引用
 * 也是函数式接口的实例。
 * 3.使用格式 ： 类（或对象）：： 方法名
 * 4. 具体分为如下的三种情况：
 *    对象 ：：非静态方法
 *    类  ：：静态方法
 *    类  ：：非静态方法
 * 5.方法引用使用的要求：
 *    要求接口中的抽象方法的形参列表和返回值类型
 *    与方法引用的形参类表和返回值类型相同
 */
public class MethodRefTest {
    /**
     * 情况一：对象：： 方法
     * comsumer中的void accept(T t)
     * pritStream中的void println(T t)
     * 大白话：
     *   如下面的 lamdba表达式中的 System.out.println(str);
     *   也就是pritStream类中的println（T t） 方法
     *   所以用pritStream类进行替换 ps::println;
     */
    @Test
    public  void  test1(){
        Consumer<String> con1=str-> System.out.println(str);
        con1.accept("深圳");
        System.out.println("**************************");
        PrintStream ps=System.out;
        Consumer<String> con2=ps::println;
        con1.accept("深圳南山区");
    }

    /**
     * supplier 中的 get()
     * emp中的getName方法
     * 大白话：
     *   如下面的 lamdba表达式中的 emp.getName();
     *   也就是Employee类中的get 方法
     *   所以用Employee类进行替换 emp::getName;
     */
    @Test
    public void test2(){
        Employee emp=new Employee(1001,"Tom",23,5600);
        Supplier<String> sup1=()-> emp.getName();
        System.out.println(sup1.get());
        System.out.println("**************************");
        Supplier sup2=emp::getName;
        System.out.println(sup2.get());
    }
}

 构造器引用&数组引用 Test:

package lamdba;

import org.junit.jupiter.api.Test;

import java.util.Arrays;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.Supplier;

/**
 * 一：构造器引用
 *      和方法引用相似， 函数式接口的抽象方法的形参列表和构造器的形参类表一致。
 *      抽象方法的返回值类型即为构造器所属的类的类型
 * 二、数组引用
 *       可以把数组看做是一个特殊的类，则写法与构造器引泳一致
 */
public class ConstructorRefTest {
    /**
     * 构造器引用
     * Supplier 中的T get()
     * Employee的构造器： Employee()
     */
    @Test
    public  void test1(){
        Supplier<Employee> sup=new Supplier<Employee>() {
            @Override
            public Employee get() {
                return new Employee();
            }
        };
        System.out.println(sup.get());
        System.out.println("**********************************");
        //lamdba表达式
        Supplier<Employee> sup1=()->new Employee();
        System.out.println(sup1.get());
        System.out.println("**********************************");
        //构造器引用, new Employee()方法 Employee类已经有了 ，所以可以构造器引用
        Supplier<Employee> sup2=Employee::new;
        System.out.println(sup2.get());
    }
    //function中的R apply(T t)
    @Test
    public void test2(){
        Function<Integer,Employee> func1=id->new Employee(id);
        Employee employee=func1.apply(1001);
        System.out.println("**********************************");
        /** 注： lamdba表达体： new Employee(id) -->  Employee类中的构造方法：
         *  public Employee(int id) {
         *         this.id = id;
         *     }
         *
         */
        Function<Integer,Employee> func2=Employee::new;
        func2.apply(1003);
    }

    /**T
     * BiFuncition中的R apply(T t,U u)   : 接受 两个参数 T ,U 然后返回一个类
     * lamdba表达体： new Employee(id,name)   已经有了构造方法 ：public Employee(int id, String name)
     * 所以可以用这个来代替
     */
    @Test
    public void test3(){
        BiFunction<Integer,String ,Employee> func1=(id,name)-> new Employee(id,name);
        System.out.println(func1.apply(1001,"Tom"));
        System.out.println("*************************************");
        BiFunction<Integer,String,Employee> func2=Employee::new;
        System.out.println(func2.apply(1002,"bich"));
    }

    /**
     * 数组引用
     * Function中的 R apply(T t)
     */
    @Test
    public void test4(){
        Function<Integer,String[]> func1= Length -> new String[Length];
        String[] arr1=func1.apply(5);
        System.out.println(Arrays.toString(arr1));
        System.out.println("**********************************");
        Function<Integer,String[]> func2= String[]::new;
        String[] arr2 = func2.apply(5);
        System.out.println(Arrays.toString(arr2));
    }
}