方法引用
在使用Lambda表达式的时候，实际我们传递的是一段解决问题的代码，给什么参数做什么操作。
Lambda冗余的场景：比如我们想要打印一个文本内容。
//准备一个函数式接口
// 准备一个函数式接口
@FunctionalInterface
public interface Printable {
// 定义唯一的抽象方法
public abstract void print(String str);
}
准备一个测试类
public class Demo01Method {
//定一个静态的方法，方法的参数传递一个函数式接口
public static void printString(Printable p) {
p.print("Hello World");
}
public static void main(String[] args) {
//传统的lambda表达式写法
printString((String str)->{
//System.out.println(name.toUpperCase());
Demo02Method demo02Method = new Demo02Method();
demo02Method.pringString(str);
});
}
}
public class Demo02Method {
//定义一个成员方法，传递一个字符串，把字符串转换为大写输出
public void pringString(String str) {
System.out.println(str.toUpperCase());//HELLO WORLD
}
}
- 在测试类中，定义一个静态方法，静态方法传递一个函数式接口Printable，函数式接口当中定义了唯一一个抽象方法print,这个print方法接收一个字符串参数，目的就是为了打印接收的字符串参数。通常我们可以使用Lambda表达式来说实现以上需求，
- 但是经过我们观察，对字符串进行控制台打印输出的操作方案中，明明已经有了现成的执行方案，System.out对象中有一个方法println(String str)，所以我们可以直接通过对象名来引用该方法println来实现在控制台打印输出字符串内容。
// 打印流对象已经确定
PrintStream printStream = System.out;
// 通过对象来引用对应的成员方法
printString(printStream::println);
注意：其中的双冒号::写法，被称之为“方法引用”，两个冒号是一种新语法。
方法引用
双冒号:: 也被归置为引用运算符
使用方法引用的使用场景
通过对象名引用成员方法
// 先准备一个类，类中需要定义一个成员方法
public class Demo02Method {
// 定义一个成员方法，传递一个字符串，把字符串转换为大写输出
public void pringUpperCaseString(String str) {
System.out.println(str.toUpperCase());
}
}
// 准备一个函数式接口
@FunctionalInterface
public interface Printable {
// 定义唯一的抽象方法
public abstract void print(String str);
}
// 准备测试类
public class Demo01Method {
// 定义一个静态的方法,方法的参数传递一个函数式接口
public static void printString(Printable p) {
p.print("Hello World");
}
public static void main(String[] args) {
/*
* 使用方法引用优化Lambda
* 对象已经是存在的method
* 成员方法也是已经存在的pringUpperCaseString
* 所以我们就可以使用对象名来引用成员方法
*/
//首先必须是对象已经存在
Demo02Method method = new Demo02Method();
printString(method::pringUpperCaseString);// HELLO WORLD
}
}
通过类名引用静态方法
比如：java.lang.Math 类中存放的都是静态方法
// 定义一个函数式接口
@FunctionalInterface
public interface Demo01MathStaticMethod {
// 定义一个抽象方法
double calculateAbs(double d);
}
// 定义一个测试类
public class Dem02MethodStatic {
// 定义一个静态方法，该方法中传递一个函数式接口,再次传递一个浮点数
public static double calc(double d,Demo01MathStaticMethod math) {
return math.calculateAbs(d);
}
public static void main(String[] args) {
// 传统的Lambda表达式写法
double num = calc(-3.14, (d) -> {
return Math.abs(d);
});
System.out.println(num);// 3.14
/*
* 使用方法引用进行优化Lambda
* 首先类名已经确定的
* 类中定义的静态方法是已经确定的
* 使用类名引用类中的静态方法
*/
double d = calc(-3.14, Math::abs);
System.out.println(d);// 3.14
}
}
备注：
- Lambda表达式写法：
d -> Math.abs(d) - 方法引用写法:
Math::abs - 这两种写法是等价的。
通过super来引用成员方法
如果存在继承关系，当Lambda中需要使用super调用时，也可以使用方法引用来优化Lambda表达式。
// 定义一个父类
public class Animal {
// 定义一个成员方法 交流的方法
public void talk() {
System.out.println("hello 我是一只动物！");
}
}
// 定义一个函数式接口
@FunctionalInterface
public interface Meet {
// 定义一个抽象方法 见面的方法
void meet();
}
// 定义一个子类
public class Cat extends Animal{
@Override
public void talk() {
System.out.println("hello 我是一只猫！");
}
// 定义一个方法 方法的参数传递一个函数式接口Meet
public void meet(Meet m){
m.meet();
}
// 定义一个成员方法 沟通的方法
public void commun() {
// 传统的Lambda表达式写法
meet(() -> {
// 创建父类的对象
// 调用父类的方法
Animal animal = new Animal();
animal.talk();
});
// 使用父类当中的方法 直接用super来调用
meet(() -> super.talk());
/*
* 使用super关键字来引用成员方法
* super已经存在的
* 父类当中的成员方法talk已经存在的
* 可以使用super引用父类当中的成员方法
*
*/
// 优化的结果
meet(super::talk);
}
public static void main(String[] args) {
new Cat().commun();
}
}
通过this来引用本类当中的成员方法
this指代当前对象，如果需要引用的方法就是本类当中的成员方法，那么可以使用this::成员方法格式来优化Lambda表达式
@FunctionalInterface
public interface Study {
// 定义一个学习的抽象方法
void study();
}
// 定义一个学生类
public class Student {
// 定义一个成员方法，方法的参数传递一个函数式接口Study
public void study(Study s) {
s.study();
}
// 定义一个work方法
public void work() {
System.out.println("我学习我快乐！");
}
// 定义一个成员方法快乐的方法
public void toHappy() {
// 传统的Lambda表达式
study(() -> {
// 创建对象
Student student = new Student();
student.work();
});
// 使用this关键字优化Lambda
//study(s);
//Student student = new Student();
study(this::work);
}
public static void main(String[] args) {
new Student().toHappy();
}
}
类的构造器引用
由于构造器的名称与类名完全一样，所以构造器的引用使用类名称::new的格式来表示
// 定义一个Model类
public class Person {
private String name;
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Person() {
}
public Person(String name) {
super();
this.name = name;
}
@Override
public String toString() {
return "Person [name=" + name + "]";
}
}
//定义一个函数式接口
@FunctionalInterface
public interface PersonCreate {
// 定义一个抽象方法
Person createPerson(String name);
}
public class TestConstructorMethod {
//定义一个方法，传入一个函数式接口PersonCreate,再传入一个字符串name
public static void printPersonName(String name,PersonCreate create) {
System.out.println(create.createPerson(name).getName());
}
public static void main(String[] args) {
// 使用传统的Lambda表达
printPersonName("小孙", name -> new Person(name));
// 使用构造器来优化Lambda表达式
printPersonName("小孙", Person::new);
/*
*Lambda表达式 name -> new Person(name)
*方法引用: Person::new
*
*/
}
}
数组的构造器引用
数组也是Object的子类对象，所以同样具有构造器，只不过语法稍微有点区别。
// 定义一个函数式接口
@FunctionalInterface
public interface BuildArrays {
// 定义唯一的抽象方法
int[] buildArrays(int length);
}
// 定义测试类
public class Demo01ArraysConstructorMethod {
// 定义一个方法，方法中传递一个函数式接口，还要传递一个数组的长度
public static int[] buildArrays(int length,BuildArrays buildArrays) {
return buildArrays.buildArrays(length);
}
public static void main(String[] args) {
// 先用Lambda表达式来操作
int[] arr01 = buildArrays(10, length -> new int[length]);
System.out.println(arr01.length);// 10
// 数组的构造器引用来优化Lambda表达式
int[] arr02 = buildArrays(10, int[]::new);
System.out.println(arr02.length);// 10
/*
* Lambda表达式：length -> new int[length]
* 方法引用：int[]::new
* 这两种写法是等价的
*
*/
}
}
推导与省略
- 如果使用Lambda，那么根据**“可推导就可以省略原则”**,无序指定参数类型，也无需指定的重写的形式—>它们可以被推导出来，所以就可以省略掉。能够使用方法引用，同样也是可以根据上下文进行推导。
- 函数式接口是Lambda的基础，而方法引用是Lambda的优化品。
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
