先上结论：
? 一： 方法引用的使用
? ?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));
}
}
