11、方法引用

方法引用

方法引用符“：：”

把已经有的方法拿来使用，当做函数式接口中抽象的方法体

方法引用

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

Integer[] arr = {6,3,4,2,0,1,9,5};
Arrays.sort(arr,类名::subtraction);
sout(arr) ;

static class int subtraction(int o1,int o2){
    return o2-o1;
}

方法引用的分类

引用静态方法

格式： 类名::静态方法

​ Integer::parseInt

 ArrayList<String> list=new ArrayList<>();
        Collections.addAll(list,"1","2","3","4","5","6","7");
        List<Integer> newList =list.stream().map(Integer::parseInt).collect(Collectors.toList());
        System.out.println(newList.get(1)+newList.get(2));

引用成员方法

格式：对象::成员方法

1. 其他类： 其他类对象::方法名
2. 本类：this::方法名
3. 父类：super::方法名
   静态方法没有this关键字

public class demo4 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"张三","李四","张三丰");
        list.stream().filter(new demo4()::junit).forEach(s -> System.out.println(s));
    }

    public boolean junit(String s){
        return s.startsWith("张")&&s.length()==3;
    }
}

引用构造方法

格式：类名::new

​ Student::new

规则:

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

public class Student {
    private String name;
    private Integer age;

    public Student() {
    }

    public Student(String s) {
        name = s.split(",")[0];
        age =Integer.parseInt(s.split(",")[1]);
    }

    public Student(String name, Integer 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 Integer getAge() {
        return age;
    }

    /**
     * 设置
     * @param age
     */
    public void setAge(Integer age) {
        this.age = age;
    }

    public String toString() {
        return "Student{name = " + name + ", age = " + age + "}";
    }
}



import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.stream.Collectors;
public class demo5 {
    public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"张三,3","李四,4");
        List newList =list.stream().map(Student::new).collect(Collectors.toList());
        System.out.println(newList);
    }

}

使用类名引用成员方法

格式:类名::成员方法

​ String::substring

规则:

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

public static void main(String[] args) {
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"aaa","bbb","ccc");
        list.stream().map(String::toUpperCase).forEach(s->System.out.println(s));
    }

引用数组的构造方法

格式:数据类型[]::new

​ int[]::new

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