方法引用
方法: 就是以前学过的方法.
引用: 就是把已有的方法拿过来用.
如何用: 当做函数式接口抽象方法的方法体.
总结: 方法引用就是把已经有的方法拿过来用, 当做函数式接口中抽象方法的方法体.
方法引用的条件:
-
引用处必须是函数式接口.
-
被引用的方法必须是已经存在的.
-
被引用方法的形参和返回值必须和抽象方法保持一致.
-
被引用的方法的功能要能满足当前的要求.
:: 是方法引用符.
示例:
引用静态方法
格式: 类名::静态方法
范例: Integer::parseInt
程序示例:
import java.util.ArrayList;
import java.util.Collections;
public class FunctionDemo2 {
public static void main(String[] args) {
/*
方法引用（引用静态方法）
格式
类::方法名
需求：
集合中有以下数字，要求把他们都变成int类型
"1","2","3","4","5"
*/
// 1.创建集合并添加元素
ArrayList<String> list = new ArrayList<>();
Collections.addAll(list, "1", "2", "3", "4", "5");
// 2.把他们都变成int类型
/* list.stream().map(new Function<String, Integer>() {
@Override
public Integer apply(String s) {
int i = Integer.parseInt(s);
return i;
}
}).forEach(s -> System.out.println(s));*/
// 1.方法需要已经存在
// 2.方法的形参和返回值需要跟抽象方法的形参和返回值保持一致
// 3.方法的功能需要把形参的字符串转换成整数
list.stream()
.map(Integer::parseInt)
.forEach(s -> System.out.println(s));
}
}
引用成员方法
格式: 对象::成员方法
其他类: 其他类对象::方法名
本类: this::方法名
父类: super::方法名
程序示例:
import java.util.ArrayList;
import java.util.Collections;
public class FunctionDemo3 {
public static void main(String[] args) {
/*
方法引用（引用成员方法）
格式
其他类：其他类对象::方法名
本类：this::方法名(引用处不能是静态方法)
父类：super::方法名(引用处不能是静态方法)
需求：
集合中有一些名字，按照要求过滤数据
数据："张无忌","周芷若","赵敏","张强","张三丰"
要求：只要以张开头，而且名字是3个字的
*/
// 1.创建集合
ArrayList<String> list = new ArrayList<>();
// 2.添加数据
Collections.addAll(list, "张无忌", "周芷若", "赵敏", "张强", "张三丰");
// 3.过滤数据（只要以张开头，而且名字是3个字的）
// list.stream().filter(s->s.startsWith("张")).filter(s->s.length() == 3).forEach(s-> System.out.println(s));
/* list.stream().filter(new Predicate<String>() {
@Override
public boolean test(String s) {
return s.startsWith("张") && s.length() == 3;
}
}).forEach(s-> System.out.println(s));*/
/* StringOperation so = new StringOperation();
list.stream().filter(so::stringJudge)
.forEach(s-> System.out.println(s));*/
// 静态方法中是没有this的
list.stream().filter(new FunctionDemo3()::stringJudge)
.forEach(s -> System.out.println(s));
}
public boolean stringJudge(String s) {
return s.startsWith("张") && s.length() == 3;
}
}
public class StringOperation {
public boolean stringJudge(String s){
return s.startsWith("张") && s.length() == 3;
}
}
程序示例:
public class App {
public static void main(String[] args) {
new LoginJFrame();
}
}
import javax.swing.*;
import java.awt.*;
public class LoginJFrame extends MyJFrame {
JButton go = new JButton("Go");
public LoginJFrame() {
// 设置图标
setIconImage(Toolkit.getDefaultToolkit().getImage("myfunction\\image\\logo.jpg"));
// 设置界面
initJframe();
// 添加组件
initView();
// 界面显示出来
this.setVisible(true);
}
// 添加组件
public void initView() {
JLabel image = new JLabel(new ImageIcon("myfunction\\image\\kit.jpg"));
image.setBounds(100, 50, 174, 174);
this.getContentPane().add(image);
go.setFont(new Font(null, 1, 20));
go.setBounds(120, 274, 150, 50);
go.setBackground(Color.WHITE);
go.addActionListener(super::method1);
this.getContentPane().add(go);
}
// 设置界面
public void initJframe() {
// 设置标题
this.setTitle("随机点名器");
// 设置大小
this.setSize(400, 500);
// 设置关闭模式
this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
// 设置窗口无法进行调节
this.setResizable(false);
// 界面居中
this.setLocationRelativeTo(null);
// 取消内部默认居中放置
this.setLayout(null);
// 设置背景颜色
this.getContentPane().setBackground(Color.white);
this.setAlwaysOnTop(true); // 置顶
}
}
import javax.swing.*;
import java.awt.event.ActionEvent;
public class MyJFrame extends JFrame {
public void method1(ActionEvent e) {
System.out.println("go按钮被点击了");
}
}
引用构造方法
格式: 类名::new
范例: Student::new
程序示例:
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
public class FunctionDemo4 {
public static void main(String[] args) {
/*
方法引用（引用构造方法）
格式
类名::new
目的：
创建这个类的对象
需求：
集合里面存储姓名和年龄，要求封装成Student对象并收集到List集合中
方法引用的规则：
1.需要有函数式接口
2.被引用的方法必须已经存在
3.被引用方法的形参和返回值，需要跟抽象方法的形参返回值保持一致
4.被引用方法的功能需要满足当前的需求
*/
// 1.创建集合对象
ArrayList<String> list = new ArrayList<>();
// 2.添加数据
Collections.addAll(list, "张无忌,15", "周芷若,14", "赵敏,13", "张强,20", "张三丰,100", "张翠山,40", "张良,35", "王二麻子,37", "谢广坤,41");
// 3.封装成Student对象并收集到List集合中
// String --> Student
/* List<Student> newList = list.stream().map(new Function<String, Student>() {
@Override
public Student apply(String s) {
String[] arr = s.split(",");
String name = arr[0];
int age = Integer.parseInt(arr[1]);
return new Student(name, age);
}
}).collect(Collectors.toList());
System.out.println(newList);*/
List<Student> newList2 = list.stream().map(Student::new).collect(Collectors.toList());
System.out.println(newList2);
}
}
public class Student {
private String name;
private int age;
public Student() {
}
public Student(String str) {
String[] arr = str.split(",");
this.name = arr[0];
this.age = Integer.parseInt(arr[1]);
}
public Student(String name, int age) {
this.name = name;
this.age = age;
}
/**
* 获取
* @return name
*/
public String getName() {
return name;
}
/**
* 设置
* @param name
*/
public void setName(String name) {
this.name = name;
}
/**
* 获取
* @return age
*/
public int getAge() {
return age;
}
/**
* 设置
* @param age
*/
public void setAge(int age) {
this.age = age;
}
public String toString() {
return "Student{name = " + name + ", age = " + age + "}";
}
}
使用类名引用成员方法
格式: 类名::成员方法
范例: String::substring
程序示例:
import java.util.ArrayList;
import java.util.Collections;
public class FunctionDemo5 {
public static void main(String[] args) {
/*
方法引用（类名引用成员方法）
格式
类名::成员方法
需求：
集合里面一些字符串，要求变成大写后进行输出
方法引用的规则：
1.需要有函数式接口
2.被引用的方法必须已经存在
3.被引用方法的形参，需要跟抽象方法的第二个形参到最后一个形参保持一致，返回值需要保持一致。
4.被引用方法的功能需要满足当前的需求
抽象方法形参的详解：
第一个参数：表示被引用方法的调用者，决定了可以引用哪些类中的方法
在Stream流当中，第一个参数一般都表示流里面的每一个数据。
假设流里面的数据是字符串，那么使用这种方式进行方法引用，只能引用String这个类中的方法
第二个参数到最后一个参数：跟被引用方法的形参保持一致，如果没有第二个参数，说明被引用的方法需要是无参的成员方法
局限性：
不能引用所有类中的成员方法。
是跟抽象方法的第一个参数有关，这个参数是什么类型的，那么就只能引用这个类中的方法。
*/
// 1.创建集合对象
ArrayList<String> list = new ArrayList<>();
// 2.添加数据
Collections.addAll(list, "aaa", "bbb", "ccc", "ddd");
// 3.变成大写后进行输出
// map(String::toUpperCase)
// 拿着流里面的每一个数据，去调用String类中的toUpperCase方法，方法的返回值就是转换之后的结果。
list.stream().map(String::toUpperCase).forEach(s -> System.out.println(s));
// String --> String
/* list.stream().map(new Function<String, String>() {
@Override
public String apply(String s) {
return s.toUpperCase();
}
}).forEach(s -> System.out.println(s));*/
}
}
引用数组的构造方法
格式: 数据类型[]:new
范例: int[]::new
程序示例:
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
public class FunctionDemo6 {
public static void main(String[] args) {
/*
方法引用（数组的构造方法）
格式
数据类型[]::new
目的：
创建一个指定类型的数组
需求：
集合中存储一些整数，收集到数组当中
细节：
数组的类型，需要跟流中数据的类型保持一致。
*/
//1.创建集合并添加元素
ArrayList<Integer> list = new ArrayList<>();
Collections.addAll(list, 1, 2, 3, 4, 5);
//2.收集到数组当中
Integer[] arr2 = list.stream().toArray(Integer[]::new);
System.out.println(Arrays.toString(arr2));
/*Integer[] arr = list.stream().toArray(new IntFunction<Integer[]>() {
@Override
public Integer[] apply(int value) {
return new Integer[value];
}
});*/
//3.打印
}
}