【JAVA入门】Day35 - 方法引用
【JAVA入门】Day35 - 方法引用
文章目录
- 【JAVA入门】Day35 - 方法引用
-
- 一、方法引用的分类
-
- 1.引用静态方法
- 2.引用成员方法
-
- 2.1 引用其他类的成员方法
- 2.2 引用本类和父类的成员方法
- 2.3 引用构造方法
- 2.4 使用类名引用成员方法
- 2.5 引用数组的构造方法
- 二、方法引用的例题
方法引用就是“把已经有的方法当作函数式接口中抽象方法的方法体”来使用。
下面是一个排序方法，它的第二个参数是一个 Comparator 接口的实现类，它是一个函数式接口，因此我们可以用方法引用改写这段代码。
Arrays.sort(arr, new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o2 - o1;
}
});
直接将已经存在的方法作为第二个参数。
public int subtraction(int n1, int n2) {
return n2 - n1;
}
Arrays.sort(arr, 比较规则 );
要使用方法引用有一些限制：
- 最重要的限制是，引用处必须是一个函数式接口，是可以把接口实现类作为参数传递的。
- 对于被引用的方法有以下三个限制：
1.被引用的方法必须已经存在了。
2.被引用的方法的形参和返回值需要跟抽象方法保持一致。
3.被引用的方法的功能要满足当前需求。
以下面这段代码为例，我们将演示方法引用相较于之前方法的简洁性。
package Functions;
import java.util.Arrays;
import java.util.Comparator;
public class FunctionDemo1 {
public static void main(String[] args) {
//需求：创建一个数组，进行倒序排序
Integer[] arr = {3,5,4,1,6,2};
//匿名内部类
Arrays.sort(arr, new Comparator<Integer>() {
@Override
public int compare(Integer o1, Integer o2) {
return o2 - o1;
}
});
//lambda表达式
Arrays.sort(arr, (Integer o1, Integer o2) -> {
return o2 - o1;
});
//lambda表达式简化格式
Arrays.sort(arr, (o1, o2) -> o2 - o1);
//方法引用
//表示引用FunctionDemo1类里面的subtraction方法
//把这个方法当作抽象方法的方法体
Arrays.sort(arr, FunctionDemo1::subtraction);
System.out.println(Arrays.toString(arr));
}
//被引用的方法可以是Java已经写好的，也可以是一些第三方工具类
public static int subtraction(int num1, int num2) {
return num2 - num1;
}
}
一、方法引用的分类
方法引用一般就分为三大类：引用静态方法、引用成员方法（这个分为引用其他类的成员方法、引用本类的成员方法、引用父类的成员方法）、引用构造方法。但是也有其他调用方式，比如：使用类名引用成员方法、引用数组的构造方法。
1.引用静态方法
格式：
类名::静态方法
范例：
Integer::parseInt
【练习】集合中有“1”“2”“3”“4”“5”五个字符串数字，要求把他们变成 int 类型。
package Functions;
import java.util.ArrayList;
import java.util.Collections;
import java.util.function.Function;
public class FunctionDemo2 {
public static void main(String[] args) {
/*
集合中有“1”“2”“3”“4”“5”五个字符串数字，要求把他们变成 int 类型。
*/
//1.创建集合并添加元素
ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, "1","2","3","4","5");
//2.常规方式
ArrayList<Integer> list2 = new ArrayList<>();
for (String s : list) {
int i = Integer.parseInt(s);
list2.add(i);
}
//3.方法引用
/* list.stream().map(new Function() {
@Override
public Integer apply(String s) {
return Integer.parseInt(s);
}
}).forEach(s -> System.out.println(s));*/
//1.方法需要已经存在
//2.方法的形参和返回值需要跟抽象方法的形参和返回值保持一致
//3.方法的功能需要把形参的字符串转换成整数
//引用的是Integer方法中的pareInt()方法
list.stream().map(Integer::parseInt).forEach(s -> System.out.println(s));
}
}
2.引用成员方法
格式：
对象::成员方法
① 其他类：
其他类对象::方法名
② 本类：
this::方法名
③ 父类：
super::方法名
2.1 引用其他类的成员方法
package Functions;
import java.util.ArrayList;
import java.util.Collections;
import java.util.function.Predicate;
public class FunctionDemo3 {
public static void main(String[] args) {
/*
只要以张开头的，而且名字是3个字的
*/
//1.创建集合
ArrayList<String> list = new ArrayList<>();
//2.添加数据
Collections.addAll(list, "张无忌","周芷若","赵敏","张强","张三丰");
//3.过滤数据
//完整写法
/* list.stream().filter(new Predicate() {
@Override
public boolean test(String s) {
return s.startsWith("张") && s.length() == 3;
}
}).forEach(s -> System.out.println(s));*/
//方法引用写法
//引用其他类的成员方法
//已知有另一个类StringOperation中有同样功能方法
//成员方法需要创建对象来使用，因此要先创建StringOperation类对象
StringOperation so = new StringOperation();
list.stream().filter(so::stringJudge);
}
}
2.2 引用本类和父类的成员方法
要注意，要引用本类成员方法时，若引用处位于 main() 方法中，它是一个静态方法，静态方法是没有 this 和 super 变量的，因此这里就只能先创建好本类的对象再进行调用。
package Functions;
import java.util.ArrayList;
import java.util.Collections;
import java.util.function.Predicate;
public class FunctionDemo3 {
public static void main(String[] args) {
/*
只要以张开头的，而且名字是3个字的
*/
//1.创建集合
ArrayList<String> list = new ArrayList<>();
//2.添加数据
Collections.addAll(list, "张无忌","周芷若","赵敏","张强","张三丰");
//3.过滤数据
//完整写法
/* list.stream().filter(new Predicate() {
@Override
public boolean test(String s) {
return s.startsWith("张") && s.length() == 3;
}
}).forEach(s -> System.out.println(s));*/
//方法引用写法
//引用本类的成员方法
//已知本类中有同样功能方法
//成员方法需要创建对象来使用，因此要先创建本类对象
list.stream().filter(new FunctionDemo3()::stringJudge);
}
public boolean stringJudge(String s) {
return s.startsWith("张") && s.length() == 3;
}
}
因此，想要使用 this 和 super，就要在一个非静态方法中，如下面的例子：
下面的例子中，我们创建了一个窗体，自己在本类中写了一个按钮的事件监听方法，并作为参数传给了按钮的addActionListener()方法，这里就是使用了本类的方法引用，这样做使得该窗体无需实现 ActionListener 接口也能自己实现按钮点击的事件逻辑。
package Functions;
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
public class LoginJFrame extends JFrame {
//创建一个按钮，点击按钮打印一句话
JButton go = new JButton("Go");
public LoginJFrame() {
//初始化界面
initJFrame();
//添加组件
initView();
//显示界面
this.setVisible(true);
}
//设置界面
public void initJFrame() {
//设置宽高
this.setSize(400,500);
}
//添加组件
public void initView() {
go.setBounds(120,274,150,50);
this.getContentPane().add(go);
//给按钮添加点击事件
//该方法形参是一个函数式接口
//因此可以在此处使用方法引用
//此时在本类可以自己写一个按钮监听的方法操作，作为方法引用，使用this::method传入
//这样可以使得该窗体不必实现ActionListener接口也能实现按钮的点击事件
go.addActionListener(this::method);
}
//自己写的按钮监听方法
public void method(ActionEvent e){
Object obj = e.getSource();
if(obj == go){
System.out.println("go按钮被点击了");
}
}
}
下面的例子中，我们让一个窗体继承了一个 MyJFrame 类，再让 MyJFrame 类继承自 JFrame，然后我们在 MyJFrame 类中自己编写了一个事件监听方法 method，然后在 MyJFrame 类中让按钮的 addActionListener() 方法引用 MyJFrame 类中的事件监听方法 method，这样就实现了引用自父类的成员方法。
父类 MyJFrame：
package Functions;
import javax.swing.*;
import java.awt.event.ActionEvent;
//注意形参和原方法保持一致
public class MyJFrame extends JFrame {
public void method(ActionEvent e){
System.out.println("go按钮被点击了");
}
}
子类 LoginJFrame：
package Functions;
import javax.swing.*;
import java.awt.*;
import java.awt.event.ActionEvent;
public class LoginJFrame extends MyJFrame {
//创建一个按钮，点击按钮打印一句话
JButton go = new JButton("Go");
public LoginJFrame() {
//初始化界面
initJFrame();
//添加组件
initView();
//显示界面
this.setVisible(true);
}
//设置界面
public void initJFrame() {
//设置宽高
this.setSize(400,500);
}
//添加组件
public void initView() {
go.setBounds(120,274,150,50);
this.getContentPane().add(go);
//给按钮添加点击事件
//该方法形参是一个函数式接口
//因此可以在此处使用方法引用
//此时在父类可以自己写一个按钮监听的方法操作，作为方法引用，使用super::method传入
go.addActionListener(super::method);
}
}
由上面的例子可以看出，方法引用可以代替函数式接口作为方法的参数传递，利用方法引用可以调整代码结构，省去实现多余的接口。
2.3 引用构造方法
我们引用构造方法就是为了创建对象。
格式：
类名::new
范例：
Student::new
以下面的例子为讲解，我们为什么要引用构造方法。
首先我们在 Student 类中重载了一个构造方法，它是为了适配构造方法引用而设的。
package Functions;
import java.util.Objects;
public class Student {
private String name;
private int age;
public Student() {
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
//用方法引用，在Student类中重载构造方法，按照上面的public Student apply(String s)的方法体重写
//str表示流里面的每一个数据
public Student(String str){
this.name = str.split("-")[0];
this.age = Integer.parseInt(str.split("-")[1]);
}
}
然后我们在测试类中引用构造方法，代替了原来的 map 方法中的函数式接口重写的方法 apply。
package Functions;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.function.Function;
import java.util.stream.Collectors;
public class FunctionDemo4 {
/*
集合里存储姓名和年龄，比如：张无忌，15
要求：将数据封装成Student对象并收集到List集合中
*/
public static void main(String[] args) {
//1.创建集合对象
ArrayList<String> list = new ArrayList<>();
//2.添加数据
Collections.addAll(list, "张无忌-15","周芷若-14","赵敏-13","张强-20","张三丰-100","张翠山-40","张良-35","王二麻子-37","谢广坤-41");
//3.封装成Student对象并收集到List集合中
//String --> Student
/* //用map方法
List newList = list.stream().map(new Function() {
@Override
public Student apply(String s) {
return new Student(s.split("-")[0], Integer.parseInt(s.split("-")[1]));
}
}).collect(Collectors.toList());*/
//用方法引用，在Student类中重载构造方法，按照上面的public Student apply(String s)的方法参数和功能重写
//构造方法没有返回值，只要保证重载的构造方法对象和你原方法返回的对象保持一致即可
List<Student> newList = list.stream().map(Student::new).collect(Collectors.toList());
}
}
这里要注意的就是，构造方法生成的对象，要和原来方法你要求返回的对象一致（姓名、年龄的格式），且构造方法的参数必须和原方法保持一致（String s）。
2.4 使用类名引用成员方法
直接用类名引用成员方法。
格式：
类名::成员方法
范例：
String::substring
【练习】集合里有一些字符串，要求变成大写后进行输出。
package Functions;
import java.util.ArrayList;
import java.util.Collections;
import java.util.function.Function;
public class FunctionDemo5 {
public static void main(String[] args) {
/*
集合里有一些字符串，要求变成大写后进行输出。
类名::成员方法
规则：
1.需要有函数式接口
2.被引用的方法必须已经存在
3.被引用方法的形参，需要跟抽象方法的第二个形参到最后一个形参保持一致，返回值需要保持一致
4.被引用的方法功能要满足当前需求
抽象方法形参的详解：
第一个参数：表示被引用方法的调用者，决定了可以引用哪些类中的方法（比如第一个参数是String类型，那么只能引用String类中的方法）
在Stream流当中，第一个参数一般都表示流里面的每一个数据
假设流里面的数据是字符串，那么使用这种方式进行方法调用，只能引用String这个类中的方法
第二个参数到最后一个参数：跟被引用的方法的形参保持一致，如果没有第二个参数，说明被引用的方法需要是无参的成员方法
*/
//1.创建集合对象
ArrayList<String> list = new ArrayList<>();
//2.添加数据
Collections.addAll(list, "aaa", "bbb", "ccc", "ddd");
//3.变成大写
//String --> String
/* list.stream().map(new Function() {
@Override
public String apply(String s) {
return s.toUpperCase();
}
}).forEach(s -> System.out.println(s));*/
//拿流里面的每一个数据，去调用String类中的toUpperCase()方法，方法的返回值就是转换之后的字符串
list.stream().map(String::toUpperCase).forEach(s -> System.out.println(s));
}
}
这种方法有一定的局限性：
1.它不能引用所有类中的成员方法。
2.它能引用的类中的成员方法，取决于它的抽象方法（上面代码中的 apply(String s)）的第一个参数类型，这个参数是什么类型，它就只能引用这个类中的方法。
3.如果这个抽象方法（apply(String s)）没有第二个及以后的参数，那么它就可以引用一个类中的空参方法。
2.5 引用数组的构造方法
格式：
数据类型[]::new
范例：
Integer[]::new
【练习】集合中存储一些整数，然后收集到数组当中。
package Functions;
import java.util.ArrayList;
import java.util.Collections;
import java.util.function.IntFunction;
public class FunctionDemo6 {
public static void main(String[] args) {
/*
细节：数组的类型，需要跟流中的数据的类型保持一致
*/
//1.创建集合
ArrayList<Integer> list = new ArrayList<>();
Collections.addAll(list,1,2,3,4,5,6,7,8,9,10);
//2.收集到数组当中
/* Integer[] arr = list.stream().toArray(new IntFunction() {
@Override
public Integer[] apply(int value) {
return new Integer[value];
}
});*/
//此时会将流中每一个数据存入生成的数组中
list.stream().toArray(Integer[]::new);
}
}
二、方法引用的例题
【练习1】集合中存一些字符串，比如：张三,23。收集到Student数组当中。
package Functions;
import JavaStudy1.Array.Array;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.stream.Collectors;
public class FuntcionTest1 {
public static void main(String[] args) {
/*
集合中存一些字符串，比如：张三,23。收集到Student数组当中。
*/
//1.创建集合添加元素
ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, "张无忌-15","周芷若-14","赵敏-13","张强-20","张三丰-100","张翠山-40","张良-35","王二麻子-37","谢广坤-41");
//2.先把字符串变成Student对象，然后再把Student对象收集起来
//String --> Student
Student[] arr = list.stream().map(Student::new).collect(Collectors.toList()).toArray(Student[]::new);
System.out.println(Arrays.toString(arr));
}
}
【练习2】创建集合并添加学生对象，要求获取姓名放到数组中。
package Functions;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
public class FunctionTest2 {
public static void main(String[] args) {
/*
创建集合并添加学生对象，要求获取姓名放到数组中。
"张无忌-15","周芷若-14","赵敏-13","张强-20","张三丰-100","张翠山-40","张良-35","王二麻子-37","谢广坤-41"
*/
//1.创建集合添加数据
ArrayList<Student> list = new ArrayList<>();
Collections.addAll(list, new Student("张无忌",15),new Student("周芷若",14),new Student("赵敏",13)
,new Student("张强",20),new Student("张三丰",100),new Student("张翠山",40));
//2.把姓名获取出来生成字符串数组
//Student --> String
String[] arr = list.stream().map(Student::getName).toArray(String[]::new);
System.out.println(Arrays.toString(arr));
}
}
【练习3】创建集合添加学生对象，把姓名和年龄拼成：张三-23的字符串，并放到数组当中。
package Functions;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
public class FunctionTest3 {
public static void main(String[] args) {
/*
创建集合添加学生对象，把姓名和年龄拼成：张三-23的字符串，并放到数组当中。
*/
//1.创建集合并添加学生对象
ArrayList<Student> list = new ArrayList<>();
Collections.addAll(list, new Student("张无忌",15),new Student("周芷若",14),new Student("赵敏",13)
,new Student("张强",20),new Student("张三丰",100),new Student("张翠山",40));
//2.取出姓名和年龄拼成字符串
//Student --> String
String[] arr = list.stream().map(Student::toString).toArray(String[]::new);
System.out.println(Arrays.toString(arr));
}
}