方法引用（十五）

JAVA
notes
Publish Date:   2023-03-24
Word Count:   2.6k
Read Count:  

方法引用（十五）

方法引用：把已存在的方法拿过来用，当做函数式接口中抽象方法的方法体。

注意：

  1. 引用处必须是函数式接口
  2. 被引用方法必须已经存在
  3. 被引用方法的形参和返回值需跟抽象方法保持一致
  4. 被引用方法的功能需要满足当前需求

方法引用符：

::

范例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
import java.util.Arrays;
import java.util.Comparator;
public class Test{
    public static void main(String[] args){
        Integer[] arr1={45,78,67,45,57,13};
        Integer[] arr2={45,78,67,45,57,13};
        Integer[] arr3={45,78,67,45,57,13};
        Integer[] arr4={45,78,67,45,57,13};
        Arrays.sort(arr1, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2-o1;
            }   
        });
        System.out.println(Arrays.toString(arr1));

        //lambda
        Arrays.sort(arr2,(Integer o1,Integer o2)->{
            return o2-o1;
        });
        System.out.println(Arrays.toString(arr2));

        //lambda省略
        Arrays.sort(arr3,(o1,o2)->o2-o1);
        System.out.println(Arrays.toString(arr3));

        //方法引用
        Arrays.sort(arr4,Test::subtraction);
        System.out.println(Arrays.toString(arr4));
    }
    public static int subtraction(int num1,int num2){
        return num2-num1;
    }
}
/*
[78, 67, 57, 45, 45, 13]
[78, 67, 57, 45, 45, 13]
[78, 67, 57, 45, 45, 13]
[78, 67, 57, 45, 45, 13]
*/

分类

  1. 引用静态方法
  2. 引用成员方法
    1. 引用其他类的成员方法
    2. 引用本类的成员方法
    3. 引用父类的成员方法
  3. 引用构造方法
  4. 其他调用方式
    1. 使用类名引用成员方法
    2. 引用数组的构造方法

引用静态方法

格式：

类名::静态方法

范例:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
import java.util.ArrayList;
import java.util.Collections;
import java.util.function.Function;

public class Test{
    public static void main(String[] args){
        ArrayList<String> list=new ArrayList<>();
        Collections.addAll(list,"1","2","3","4");
        list.stream().map(new Function<String, Integer>() {
            @Override
            public Integer apply(String s) {
                return Integer.parseInt(s);
            }
        }).forEach(s-> System.out.print(s+" "));
        System.out.println();
        list.stream().map(Integer::parseInt).forEach(s-> System.out.print(s+" "));
    }
}
/*
1 2 3 4 
1 2 3 4 
*/

引用成员方法

格式：对象::对象方法

  1. 其他类：其他类对象::方法名
  2. 本类：this::方法名
    • 引用处不能是静态方法，静态方法中没有this
  3. 父类：super::方法名
    • 引用处不能是静态方法，静态方法中没有super

引用其他类的成员方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
//只打印集合中以“路”开头并且长度为3的字符串
//Test.java
import java.util.ArrayList;
import java.util.Collections;
import java.util.function.Predicate;
public class Test{
    public static void main(String[] args){
        ArrayList<String> list=new ArrayList<>();
        Collections.addAll(list,"张三","路人甲","李四","路人乙","路丙");
        list.stream().filter(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.startsWith("路")&&s.length()==3;
            }
        }).forEach(s-> System.out.print(s+" "));

        //方法引用
        System.out.println();
        list.stream().filter(new StringController()::StringJudge).forEach(s-> System.out.print(s+" "));
    }
}
/*
路人甲 路人乙 
路人甲 路人乙 
*/
//StringController.java
public class StringController {
    public boolean StringJudge(String s) {
        return s.startsWith("路")&&s.length()==3;
    }
}

引用本类的成员方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
//Test.java
public class Test{
    public static void main(String[] args){
        new StringController();
    }
}

//StringController.java
import java.util.ArrayList;
import java.util.Collections;
public class StringController {
    public StringController(){
        ArrayList<String> list=new ArrayList<>();
        Collections.addAll(list,"aaa","ccc","vbb","ddd");
        list.stream().forEach(this::print);
    }
    public void print(String s){
        System.out.println(s);
    }
}
/*
aaa
ccc
vbb
ddd
*/

获取父类的成员方法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
//Test.java
public class Test{
    public static void main(String[] args){
        new StringController();
    }
}

//Father.java
public class Father {
    public void print(String s){
        System.out.println(s);
    }
}

//StringController.java
import java.util.ArrayList;
import java.util.Collections;
public class StringController extends Father{
    public StringController(){
        ArrayList<String> list=new ArrayList<>();
        Collections.addAll(list,"aaa","ccc","vbb","ddd");
        list.stream().forEach(super::print);
    }
}
/*
aaa
ccc
vbb
ddd
*/

引用构造方法

格式：

类名::new

范例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
//Test.java
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
public class Test{
    public static void main(String[] args){
        ArrayList<String> list=new ArrayList<>();
        Collections.addAll(list, "zhangsan,23","lisi,24","wangwu,25");
        List<Student> list1=list.stream().map(Student::new).collect(Collectors.toList());
        System.out.println(list1);
    }
}

//Student.java
public class Student {
    private String name;
    private int age;
    public Student(){}
    public Student(String str){
        this.name=str.split(",")[0];
        this.age=Integer.parseInt(str.split(",")[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 + "}";
    }
}
/*
[Student{name = zhangsan, age = 23}, Student{name = lisi, age = 24}, Student{name = wangwu, age = 25}]
*/

类名引用成员方法

格式：类名::成员方法

该方法引用的规则：（该规则仅限于类名引用成员方法）

  1. 需要有函数式接口
  2. 被引用的方法已经存在
  3. 被引用方法的形参，需跟抽象方法的第二个形参到最后一个形参一致，返回值需保持一致
  4. 被引用的方法需要满足当前的需求

抽象方法形参的详解：

第一个参数：表示被引用方法的调用者，决定了可以引用那些类的方法，比如：在Stream流中，第一个参数一般都表示流里面的每一个数据，假设流里面的数据是字符串，那么使用这种方式进行方法引用，只能引用String类里的方法。

第二个参数到最后一个参数：跟被引用方法的形参保持一致，若无第二个参数，则该被引用的方法需要是无参的成员方法。

范例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
//将集合中字符串以大写的形式输出
import java.util.ArrayList;
import java.util.Collections;
import java.util.function.Function;
public class Test{
    public static void main(String[] args){
        ArrayList<String> list=new ArrayList<>();
        Collections.addAll(list, "zhangsan","lisi","wangwu");
        list.stream().map(new Function<String, String>() {
            @Override
            public String apply(String s) {
                return s.toUpperCase();
            }
        }).forEach(s-> System.out.print(s+" "));
        System.out.println();

        //类名引用成员方法
        list.stream().map(String::toUpperCase).forEach(s-> System.out.print(s+" "));
    }
}

引用数组的构造方法

格式：

数据类型::new

目的：创建一个指定类型的数组。

注：数组的类型需跟流中的类型保持一致。

范例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
//集合存取一些整数，收集到数组中
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.function.IntFunction;

public class Test{
    public static void main(String[] args){
        ArrayList<Integer> list=new ArrayList<>();
        Collections.addAll(list, 1,2,3,4,5,6,7,8,9);
        Integer[] arr=list.stream().toArray(new IntFunction<Integer[]>() {
            @Override
            public Integer[] apply(int value) {
                return new Integer[value];
            }
        });
        System.out.println(Arrays.toString(arr));

        Integer[] arr2=list.stream().toArray(Integer[]::new);
        System.out.println(Arrays.toString(arr2));
    }
}
/*
[1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
*/

范例

例1

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
/*
集合中存储一些字符串的数据，比如："张三,18","李四,19","王五,20"
使用引用方法收集到Student类型的数组中
*/
//Test.java
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;

public class Test{
    public static void main(String[] args){
        ArrayList<String> list=new ArrayList<>();
        Collections.addAll(list,"张三,18","李四,19","王五,20");
        Student[] students=list.stream().map(Student::new).toArray(Student[]::new);
        System.out.println(Arrays.toString(students));
    }
}
//Student.java
public class Student {
    private String name;
    private int age;
    public Student(){}
    public Student(String str){
        this.name=str.split(",")[0];
        this.age=Integer.parseInt(str.split(",")[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 + "}";
    }
}

例2

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
/*
创建集合添加学生对象，学生对象属性：name,age
只获取姓名并放到数组当中（使用方法引用完成）
*/
//Student.java
public class Student {
    private String name;
    private int age;
    public Student(){}
    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 + "}";
    }
}
//Test.java
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;

public class Test{
    public static void main(String[] args){
        ArrayList<Student> list=new ArrayList<>();
        Student stu1=new Student("张三",18);
        Student stu2=new Student("李四",19);
        Student stu3=new Student("王五",20);
        Collections.addAll(list,stu1,stu2,stu3);
        String[] s=list.stream().map(Student::getName).toArray(String[]::new);
        System.out.println(Arrays.toString(s));
    }
}
/*
[张三, 李四, 王五]
*/

例3

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
/*
创建集合添加学生对象，学生对象属性：name,age
把姓名和年龄拼接成：张三-23的字符串，并放到数组当中（使用方法引用完成）
*/
//Student.java
public class Student {
    private String name;
    private int age;
    public Student(){}
    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 + "}";
    }
    public String getAll(){
        return name+","+age;
    }
}
//Test.java
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;

public class Test{
    public static void main(String[] args){
        ArrayList<Student> list=new ArrayList<>();
        Student stu1=new Student("张三",18);
        Student stu2=new Student("李四",19);
        Student stu3=new Student("王五",20);
        Collections.addAll(list,stu1,stu2,stu3);
        String[] s=list.stream().map(Student::getAll).toArray(String[]::new);
        System.out.println(Arrays.toString(s));
    }
}
/*
[张三,18, 李四,19, 王五,20]
*/
Author: ljs
Link: http://example.com/2023/03/24/J15/
Reprint policy: All articles in this blog are used except for special statements CC BY 4.0 reprint polocy. If reproduced, please indicate source ljs !
JAVA
赏
评论
  TOC