菜鸟之路Day13一一方法引用

简介: ### 菜鸟之路Day13——方法引用作者:blue 日期:2025.1.31本文介绍了Java中的方法引用,它是对Stream流的优化,简化了代码结构。方法引用可以用于静态方法、成员方法和构造方法。通过将已有方法作为函数式接口的实现,减少了匿名内部类和Lambda表达式的冗余。文中通过多个实例演示了方法引用的应用场景,包括倒序排序、字符串转换、集合过滤及对象构造等操作,帮助读者更好地理解和使用这一特性。

菜鸟之路Day13一一方法引用

作者:blue

时间:2025.1.31

0.概述

内容学习至黑马程序员BV1yW4y1Y7Ms,方法引用感觉是对Stream流的一个优化,让stream流可以更加简介,如果多个匿名内部类都要使用同一种方法,那么方法引用在此处也大有用处。

1.方法引用

把已经有的方法拿过来用,当作函数式接口中抽象方法的方法体

要求:1.引用处必须是函数式接口;

​ 2.被引用的方法必须已经存在

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

​ 4.被引用方法的功能要满足当前要求

1.1方法引用初体验

public class Test1 {
   
    public static void main(String[] args) {
   
        //要求倒序排序
        Integer[] arr = {
   1,2,3,4,5,6,7,8,9};

        //匿名内部类
        /*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;
            }
        );*/

        //方法引用
        //表示引用Test类中的cmp方法
        //把这个方法当作抽象方法的方法体
        Arrays.sort(arr,Test1::cmp);

        System.out.println(Arrays.toString(arr));
    }
    public static int cmp(int a,int b){
   
        return b-a;
    }
}
AI 代码解读

1.2引用静态方法

格式:类名::静态方法

范例:Integer::parseInt

练习:集合中有以下数字,要求把他们都变成int类型 "1" "2" "3" "4" "5"

public class Test2 {
   
    public static void main(String[] args) {
   
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"1","2","3","4","5");

        //原来Stream流的做法
        /*list.stream().map(new Function<String, Integer>() {
            @Override
            public Integer apply(String s) {
                int i = Integer.parseInt(s);
                return i;
            }
        });*/

        //map这个位置是一个函数式接口,我们在Integer里面正好有对应的方法,所以我们可以使用方法引用
        //1.方法需要已经存在
        //2.方法的形参和返回值需要跟抽象方法的形参和返回值保持一致
        //3.方法的功能需要把形参的字符串转换成整数
        list.stream().map(Integer::parseInt).forEach(s-> System.out.println(s));

    }
}
AI 代码解读

1.3引用成员方法

格式:对象::成员方法

①其他类:其他类对象::方法名

(注意以下两种引用本类和父类的方法,在引用处不能是静态方法,因为在静态方法中是没有this和super关键字的)

②本类:this::方法名

③父类:super::方法名

练习1:①其他类:其他类对象::方法名

public class Test3 {
   
    public static void main(String[] args) {
   
        /*需求:集合中有一些名字,按照要求过滤
        * 数据:"张无忌","周芷若","赵敏","张强","张三丰"
        * 要求:只要以张开头,而且名字是3个字的*/

        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"张无忌","周芷若","赵敏","张强","张三丰");

        //原来Stream流的写法
        //list.stream().filter(name->name.startsWith("张")).filter(name->name.length()==3).forEach(name-> System.out.println(name));

        //成匿名内部类,可以内部的方法抽象成一个类
        /*list.stream().filter(new Predicate<String>() {
            @Override
            public boolean test(String s) {
                return s.startsWith("张")&&s.length()==3;
            }
        }).forEach(s-> System.out.println(s));*/

        //利用引用成员方法,①其他类:其他类对象::方法名
        list.stream().filter(new StringOperation()::test).forEach(s -> System.out.println(s));
    }
}
AI 代码解读

1.4引用构造方法

格式:类名::new

范例:Student::new

public class Test4 {
   
    public static void main(String[] args) {
   
        //需求:集合里面存储姓名和年龄,要求封装成Student对象并收集到List集合中
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"xz,22","xm,20","xt,21","xl,21","xw,18","xn,19");

        //封装成Student对象并收集到List集合中
        //String->Student,做的是类型转换所以调用map方法
        //Stream流的做法
        /*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);*/

        //利用方法引用中的,引用构造方法
        //在Student类中新增一个匹配的构造方法
        List<Student> newList = list.stream().map(Student::new).collect(Collectors.toList());

        System.out.println(newList);
    }
}
AI 代码解读

Student的javabean类,要有对应的方法

package practice;

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

    public Student() {
   
    }

    //在Student类中新增一个符合要求的构造方法
    public Student(String s) {
   
        String[] arr = s.split(",");
        String name = arr[0];
        int age = Integer.parseInt(arr[1]);
        this.name = name;
        this.age = age;
    }

    public Student(String name, int age) {
   
        this.name = name;
        this.age = age;
    }

    public String getName() {
   
        return name;
    }

    public void setName(String name) {
   
        this.name = name;
    }

    public int getAge() {
   
        return age;
    }

    public void setAge(int age) {
   
        this.age = age;
    }

    @Override
    public String toString() {
   
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
AI 代码解读

1.5其他调用方式

①使用类名引用成员方法

格式:类名::成员方法

范例:String::substring

练习:集合里面一些字符串,要求变成大写后进行输出

public class Test5 {
   
    public static void main(String[] args) {
   
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"aaa","bbb","ccc","ddd");

        //Stream流的方法
        /*list.stream().map(new Function<String, String>() {

            @Override
            public String apply(String s) {
                return s.toUpperCase();
            }
        }).forEach(s-> System.out.println(s));*/


        //方法引用,使用类名引用成员方法
        list.stream().map(String::toUpperCase).forEach(s-> System.out.println(s));
    }
}
AI 代码解读

②引用数组的构造方法

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

范例:int[]::new

练习:集合中存储一些整数,收集到数组当中

public class Test6 {
   
    public static void main(String[] args) {
   
        ArrayList<Integer> list = new ArrayList<>();
        Collections.addAll(list,1,2,3,4,5,6,7,7,8);

        //stream流的方式:
        /*Integer[] arr = 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));
    }
}
AI 代码解读

1.6方法引用练习

练习1:集合中存储一些字符串数据,比如:"张三,23"

收集到Student类型的数组中。(在这个类型中,所使用的javabean类,)

public class practice1 {
   
    public static void main(String[] args) {
   
        ArrayList<String> list = new ArrayList<>();
        Collections.addAll(list,"xz,22","xm,20","xt,21","xl,21","xw,18","xn,19");

        //先用中间方法map将对象类型转为Student,再利用终结方法toArray变成数组
        Student[] arr = list.stream().map(Student::new).toArray(Student[]::new);

        System.out.println(Arrays.toString(arr));
    }
}
AI 代码解读

练习2:创建集合添加学生对象,学生对象属性:name,age

只获取姓名放到数组当中

(Student类中新增的方法)

public String apply(Student student) {
   
        return student.getName();
}
AI 代码解读
public class practice2 {
   
    public static void main(String[] args) {
   
        ArrayList<Student> list = new ArrayList<>();
        Student stu1 = new Student("xz",21);
        Student stu2 = new Student("xw",26);
        Student stu3 = new Student("xn",20);
        Collections.addAll(list,stu1,stu2,stu3);


        /*list.stream().map(new Function<Student, String>() {
            @Override
            public String apply(Student student) {
                return student.getName();
            }
        });*/

        //将匿名内部类中获取部分数据的方法抽象为Student的一个成员方法,然后利用其他类对象::方法名类型的方法引用
        String[] arr = list.stream().map(new Student()::apply).toArray(String[]::new);
        System.out.println(Arrays.toString(arr));
    }
}
AI 代码解读

练习3:创建集合,添加学生对象,学生对象属性:name,age

把姓名和年龄拼接成:"张三-23"的字符串,并放到数组当中(使用方法引用完成)

(写在Student类中的静态方法)

 public static String test(Student student) {
   
        //搞一个链式编程
        return new StringBuilder().append(student.getName()).append("-").append(student.getAge()).toString();
    }
AI 代码解读
public class practice3 {
   
    public static void main(String[] args) {
   
        ArrayList<Student> list = new ArrayList<>();
        Student stu1 = new Student("xz",21);
        Student stu2 = new Student("xw",26);
        Student stu3 = new Student("xn",20);
        Collections.addAll(list,stu1,stu2,stu3);

        /*list.stream().map(new Function<Student, String>() {
            @Override
            public String apply(Student student) {
                //搞一个链式编程
                return new StringBuilder().append(student.getName()).append("-").append(student.getAge()).toString();
            }
        });*/

        //将上述apply方法抽象成student类中的一个静态方法,使用(类名::成员方法)的方式来拼接字符串
        String[] arr = list.stream().map(Student::test).toArray(String[]::new);
        System.out.println(Arrays.toString(arr));
    }
}
AI 代码解读
目录
相关文章
|
27天前
|
菜鸟之路Day10一一集合进阶(三)
《菜鸟之路Day10——集合进阶(三)》由blue编写,发布于2025年1月28日。文章基于黑马程序员教程,介绍了Java中双列集合的特点、体系结构及Map接口的常见API和遍历方式。重点讲解了HashMap、LinkedHashMap和TreeMap的特性与应用场景,并通过多个实例演示了它们的使用方法,帮助读者深入理解集合类的高级用法。
132 73
|
25天前
|
菜鸟之路Day11-12一一集合进阶(四)
### 菜鸟之路 Day11-12:集合进阶(四) 作者:blue 时间:2025.1.29-1.30 本文详细介绍了Java集合的高级用法,包括可变参数、Collections工具类、综合练习、不可变集合和Stream流。通过具体代码示例,讲解了可变参数的使用规则、Collections常用API、随机点名练习、不可变集合的创建方法以及Stream流的操作步骤。内容丰富实用,适合初学者深入理解Java集合框架。
47 18
|
29天前
|
菜鸟之路Day09一一集合进阶(二)
《菜鸟之路Day09——集合进阶(二)》由blue撰写于2025年1月27日。本文总结了Java集合框架的高级用法,重点介绍了泛型、Set系列集合等内容。泛型特性自JDK5引入,允许在编译阶段约束数据类型,避免运行时异常,并通过泛型类、方法和接口的应用增强了代码灵活性。Set系列集合包括HashSet、LinkedHashSet和TreeSet,分别实现了无序、有序及可排序的元素存储,支持多种遍历方式如迭代器、增强for循环和Lambda表达式。此外,文章详细解析了TreeSet的自然排序与比较器排序机制,提供了丰富的代码示例帮助理解。
48 17
|
30天前
|
菜鸟之路Day08一一集合进阶(一)
《菜鸟之路Day08——集合进阶(一)》由blue撰写于2025年1月26日,深入探讨了五道经典算法题及单列集合的相关知识。文章首先通过自定义排序、不死神兔、猴子吃桃子、爬楼梯及其变种等题目,详细讲解了Java中数组和动态规划的应用;接着介绍了单列集合的体系结构,重点解析了Collection接口的常用方法及遍历方式(迭代器、增强for、Lambda表达式),并进一步探讨了List接口的特点与遍历方法,最后简要介绍了LinkedList的独特API。
32 6
C++菜鸟学习笔记系列(17)——函数基础
C++菜鸟学习笔记系列(17)——函数基础
111 0
《代码精进之路:DDD阿里云版》电子版地址
5.21【代码精进之路:DDD阿里云版】
360 0
《代码精进之路:DDD阿里云版》电子版地址