方法的引用
直接访问类或者实例的已经存在的方法或者构造方法，方法的引用提供了一种引用提供了一种引用而不执行方法的方式，如果抽象方法的实现恰巧可以使用调用另外一个方法来实现，就有可能可以使用方法引用
方法引用分类
| 类型 | 语法 | 对应的lambda表达式 | 说明 |
|---|---|---|---|
| 静态方法引用 | 类名::staticMethod | (args)->类名.staticMethod | 如果函数式接口恰巧可以通过调用一个静态方法来实现，就可以使用调动静态方法来引用 |
| 实例方法引用 | inst::instMethod | (args)-> inst.instMethod | 如果函数式接口恰巧可以通过调用一个实例的实例方法来实现，就可以使用调动实例方法来引用 |
| 对象方法引用 | 类名::instMethod | (inst,args)->inst.instMethod | 抽象方法的第一个参数类型刚好是实例方法的类型，抽象方法剩余的参数恰巧可以当作实例方法的参数。如果函数式接口能有上面说的实例方法调用的话，那么就可以使用对象方法引用 |
| 构造方法引用 | 类名::new | (args)->new 类名（args） | 如果函数式接口恰巧可以通过调用一个类的构造方法来实现，就可以使用调动实例方法来引用 |
静态方法引用
package lambda1;
import java.util.function.Supplier;
/**
* 静态方法引用
* 如果函数式接口恰巧可以通过调用一个静态方法来实现，就可以使用调动静态方法来引用
*/
public class StaticMethod {
/**
* 静态方法
* @return
*/
private static String insert() {
return "hello lambda";
}
public static void main(String[] args) {
// 该函数式接口表示输出。
// lambda表达式
Supplier s = () -> {
return StaticMethod.insert();
};
System.out.println("lambda表达式:" + s.get());
// 方法的引用
Supplier s1 = StaticMethod::insert;
System.out.println("方法的引用:" + s1.get());
}
}
实例方法引用
package lambda1;
import java.util.function.Supplier;
/**
* 实例方法引用
* 如果函数式接口恰巧可以通过调用一个实例的实例方法来实现，就可以使用调动实例方法来引用
*/
public class InstanceMethod {
/**
* 实例方法
* @return
*/
private String insert() {
return "hello lambda";
}
public static void main(String[] args) {
Supplier s = () -> {
return new InstanceMethod().insert();
};
System.out.println("lambda表达式:" + s.get());
// 方法的引用
Supplier s1 = new InstanceMethod()::insert;
System.out.println("方法的引用:" + s1.get());
}
}
对象方法引用
package lambda1;
import java.util.function.BiConsumer;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;
/**
*
* 对象方法引用（该函数式接口的抽象方法必须有输入参数）
* 抽象方法的第一个参数类型刚好是实例方法的类型，抽象方法剩余的参数恰巧可以当作实例方法的参数。如果函数式接口能有上面说的实例方法调用的话，那么就可以使用对象方法引用
*/
public class ObjectMethod {
public static void main(String[] args) {
Supplier s=()->null;//此函数式接口不能用对象方法引用
/**
* Consumer
*/
Consumer c1=(Too too)->new Too().show();
Consumer c2=Too::show;
Consumer c3=(Too too)->new Too2().show();
//Consumer c4=Too2::show;//这个就不行，因为抽象方法的第一个参数类型(Too)不是实例方法的类型
c1.accept(new Too());
c2.accept(new Too());
c3.accept(new Too());
/**
* Function
*/
Function f1=(too2)->new Too2().show1();;
Function f2=Too2::show1;
System.out.println(f1.apply(new Too2()));
System.out.println(f2.apply(new Too2()));
/**
* BiConsumer
*/
BiConsumer bc1=(too,str)->new Too().show1(str);
BiConsumer bc2=Too::show1;
bc1.accept(new Too(), "1");
bc2.accept(new Too(), "2");
}
}
class Too{
public void show() {
System.out.println("Too show invoke");
}
public void show1(String str) {
System.out.println("Too show invoke:"+str);
}
}
class Too2{
public void show() {
System.out.println("Too2 show invoke");
}
public String show1() {
return "Too2 show1 invoke";
}
}
构造方法引用
package lambda1;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import java.util.function.BiConsumer;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;
/**
* 构造方法方法引用
* 如果函数式接口恰巧可以通过调用一个实例的实例方法来实现，就可以使用调动实例方法来引用
*/
public class StructureMethod {
public static void main(String[] args) {
// 调用无参构造方法
Supplier s1 = () -> new Man();
Supplier s2 = Man::new;
s1.get();
s2.get();
// 调用无参构造方法；可以通过此函数式接口代替 Object obj=new Object(),华丽转身
Supplier> s3 = ArrayList::new;
Supplier> s4 = HashSet::new;
Supplier s5 = String::new;
Supplier s6 = Thread::new;
List city=s3.get();//不可变对象一个原理，动动脑子
city.add("福州");
city.add("北京");
city.add("上海");
for (int i = 0; i c1 = str -> new Man(str);
Consumer c2 = Man::new;
c1.accept("c1的实参");
c2.accept("c2的实参");
// 相应的两个参数的构造方法可以使用
BiConsumer b1 = (str, num) -> new Man(str, num);
BiConsumer b2 = Man::new;
b1.accept("b1的字符串", 5);
b2.accept("b2的字符串", 3);
Function f1 = (str) -> Integer.valueOf(str);
Function f2 = Integer::valueOf;
f1.apply("122");
f2.apply("133");
// 因为man中有无参构造方法所以f3可以，
// 因为f4中有只有一个String类型的有参构造方法所以可以，
// f5是调用了只有一个String类型的构造方法，因为Function有一个输入参数，所以会匹配
Function f3 = (str) -> new Man();
Function f4 = (str) -> new Man(str);
Function f5 = Man::new;
f3.apply("111");
f4.apply("111");
f5.apply("111");
}
}
class Man{
public Man() {
System.out.println("调用Man的无参构造方法！");
}
public Man(String str) {
System.out.println("调用Man的参数为"+str+"的有参构造方法！");
}
public Man(String str,int num) {
System.out.println("调用Man的参数为字符串"+str+"和数值"+num+"的有参构造方法！");
}
}