方法的引用_方法引用的引用表示什么-CSDN博客

本文链接：https://blog.csdn.net/keleID/article/details/132245128

（1）什么是方法的引用：

方法引用是一种用于简化 Lambda 表达式的语法结构，特别适用于那些仅仅调用现有方法的 Lambda 表达式。它允许你直接引用现有的方法作为 Lambda 表达式，而不是通过编写一个具有调用该方法的 Lambda 表达式。（把以已经有的方法拿过来用，当作函数式接口中的抽象方法的方法体）

要求：

1、引用处是函数式接口（也是可以写成lambda表达式的一个条件）

2、被引用的方法必须是已经存在的，不存在的话还要自己写

3、被引用的方法的形参和返回值需要和抽象方法的保持一致

4、被引用的方法要满足当前的需求

（2）引用方法的类型：

1、引用静态方法：

格式:

类名 :: 方法名

public class 方法引用 {
    public static void main(String[] args) {
        //静态引用

        //创建集合
        ArrayList<String> list =new ArrayList<>();
        Collections.addAll(list,"1","2","3","4","5","6","7");

        //转换成int
/*
        list.stream().map(new Function<String, Integer>() {
            @Override
            public Integer apply(String s) {

                return Integer.parseInt(s);
            }
        }).forEach(s -> System.out.println(s));
*/
        //Integer--------类名   parseInt-------静态方法
        list.stream().map(Integer::parseInt).forEach(s-> System.out.println(s));

    }

}

2、引用成员方法：

格式:

对象 :: 方法名

其他类: 其他类对象 :: 方法名
本类: this :: 方法名
父类: super :: 方法名

举例子咯!

其他类

javabean:

public class Singjudge {


    public boolean judge(String s) {
        return s.length() > 2 && s.startsWith("刘");
    }


}

test:

import java.util.ArrayList;
import java.util.Collections;

public class 方法引用成员方法 {
    public static void main(String[] args) {
        //创建集合
        ArrayList<String> lsit =new ArrayList<>();
        Collections.addAll(lsit,"蔡徐坤","叶星成","鹿哈","刘不甜","吴亦凡","顾宇佳","肖振良"
                ,"赵丽颖","杨颖","高圆圆","张天天","刘诗诗","杨幂","迪丽娜扎","杨过");


        //数据流
        lsit.stream().filter(s -> s.length()>2&&s.startsWith("刘")).forEach(s -> System.out.println(s));
        System.out.println("-------------------------");

        //改写成成员方法
        lsit.stream().filter(new Singjudge()::judge).forEach(s -> System.out.println(s));

        //本类
        /*lsit.stream().filter(this::judge).forEach(s -> System.out.println(s)); 注释掉啦,不信可以解开看看*/
        //呜呜呜!报错了,因为静态方法没有this-------解决办法创建本类对象然后然后调用方法
        System.out.println("-------------------------");
        lsit.stream().filter(new 方法引用成员方法()::judge).forEach(s -> System.out.println(s));
    }
    public boolean judge(String s) {
        return s.length() > 2 && s.startsWith("刘");
    }

}

3、引用构造方法：

格式:

类名 :: new

jacabean:

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 + "}";
    }
}

test:

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.function.Function;
import java.util.stream.Collectors;

public class 引用构造方法 {
    public static void main(String[] args) {
        //创建集合
        ArrayList<String> list =new ArrayList<>();
        Collections.addAll(list,"张无忌,15","周芷若,14","赵敏,13","张强,20","张三封,100","张存善,40","张良,35" ,
                "王二麻子,37","谢广坤,41");


        List<Student> collect = list.stream().map(new Function<String, Student>() {
            @Override
            public Student apply(String s) {
                String name = s.split(",")[0];
                int age = Integer.parseInt(s.split(",")[1]);
                return new Student(name, age);

            }
        }).collect(Collectors.toList());

        List<Object> collect1 = list.stream().map(Student::new).collect(Collectors.toList());


        System.out.println(collect);
        System.out.println("----------------------");
        System.out.println(collect1);
    }

}

构造方法没有返回值!

4、其他方式：

使用类名去引用成员方法

格式:

类名 :: 成员方法

1、引用处是函数式接口（也是可以写成lambda表达式的一个条件）

2、被引用的方法必须是已经存在的，不存在的话还要自己写

3、被引用的方法的形参和返回值需要和抽象方法的保持一致

4、被引用的方法要满足当前的需求

5、抽象方法形参的详解

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

第二个参数到最后一个参数：是跟引用放法的形参保持一致，如果没有第二个参数，说明被引用的方法是需要无参数的成员方法。

package com.day20;

import java.util.ArrayList;
import java.util.Collections;
import java.util.function.Function;

public class 用类引用成员方法 {
    public static void main(String[] args) {
        //创建集合
        ArrayList<String> list =new ArrayList<>();

        Collections.addAll(list,"aaa","bbb","ccc","ddd","eee","fff");

        //数据流
        list.stream().map(new Function<String, String>() {
            @Override
            public String apply(String s) {

                return s.toUpperCase();
            }
        }).forEach(s -> System.out.println(s));
        //相当于流里面的每一个数据都去调用同UpperCase这方法，然后方法的返回值就是String类型的

        list.stream().map(String::toUpperCase).forEach(s -> System.out.println(s));
    }
}

引用数组的构造方法：

格式:

数据类型[ ] :: new

注意:数组的类型要和流里面的数据类型一致!

package com.day20;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.function.IntFunction;

public class 引用数组的构造方法 {
    public static void main(String[] args) {
        //创建集合
        ArrayList<Integer> list = new ArrayList<>();
        Collections.addAll(list, 1, 2, 3, 4, 5, 6, 7);

        //存入数组
        Integer[] array = list.stream().toArray(new IntFunction<Integer[]>() {
            @Override
            public Integer[] apply(int value) {
                return new Integer[value];
            }
        });

        //方法引用
        Object[] array1 = list.stream().toArray(Integer[]::new);


        System.out.println(Arrays.toString(array1));
    }
}