Java8方法引用：简洁高效的编程利器

原创 于 2025-06-28 00:07:47 发布 · 478 阅读 · 2 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#java #开发语言

方法引用概述

方法引用是Java 8引入的Lambda表达式的一种简化写法，用于直接引用已有的方法。它通过::符号连接目标对象或类与方法名，适用于函数式接口的实现。方法引用分为静态方法引用、实例方法引用、构造方法引用等类型。

实例：

public class FunctionDemo1 {
    public static void main(String[] args) {
        //需求：创建一个数组，进行倒序排列
        Integer[] arr = {3, 5, 4, 1, 6, 2};
        //匿名内部类

       /* Arrays.sort(arr, new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return o2 - o1;
            }
        });*/



        //lambda表达式
        //因为第二个参数的类型Comparator是一个函数式接口
       /* Arrays.sort(arr, (Integer o1, Integer o2)->{
            return o2 - o1;
        });*/

        //lambda表达式简化格式
        //Arrays.sort(arr, (o1, o2)->o2 - o1 );


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

        //表示引用FunctionDemo1类里面的subtraction方法
        //把这个方法当做抽象方法的方法体
        Arrays.sort(arr, FunctionDemo1::subtraction);

        System.out.println(Arrays.toString(arr));

    }



    //可以是Java已经写好的，也可以是一些第三方的工具类
    public static int subtraction(int num1, int num2) {
        return num2 - num1;
    }
}

引用静态方法

语法：类名::静态方法名
适用于引用类的静态方法，传递给函数式接口时要求参数和返回值匹配。

// 示例：引用Integer的静态方法parseInt
Function<String, Integer> converter = Integer::parseInt;
System.out.println(converter.apply("123")); // 输出: 123

实例：

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));



    }
}

引用其他类的成员方法

语法：对象实例::实例方法名
适用于通过对象实例引用其非静态方法。

// 示例：引用String的实例方法toUpperCase
String str = "hello";
Supplier<String> supplier = str::toUpperCase;
System.out.println(supplier.get()); // 输出: HELLO

实例：

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

引用本类或父类的成员方法

语法：this::实例方法名 或 super::父类方法名
适用于当前类或父类中定义的实例方法。

class Parent {
    void print() {
        System.out.println("Parent method");
    }
}

class Child extends Parent {
    void invokeMethods() {
        Runnable parentMethod = super::print;
        Runnable childMethod = this::printChild;
        parentMethod.run(); // 输出: Parent method
        childMethod.run();  // 输出: Child method
    }

    void printChild() {
        System.out.println("Child method");
    }
}

实例：

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);//置顶
    }





}

public class MyJFrame extends JFrame {

    public void method1(ActionEvent e) {
        System.out.println("go按钮被点击了");
    }
}

public class App {
    public static void main(String[] args) {
        new LoginJFrame();
    }
}

引用构造方法

语法：类名::new
适用于通过函数式接口创建对象实例。

// 示例：引用String的构造方法
Function<String, String> stringConstructor = String::new;
System.out.println(stringConstructor.apply("new string")); // 输出: new string

实例：

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的compareToIgnoreCase方法
BiFunction<String, String, Integer> comparator = String::compareToIgnoreCase;
System.out.println(comparator.apply("A", "a")); // 输出: 0（忽略大小写比较）

实例：

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
适用于创建指定长度的数组。

// 示例：引用Integer数组的构造方法
Function<Integer, Integer[]> arrayCreator = Integer[]::new;
Integer[] array = arrayCreator.apply(3); // 创建长度为3的Integer数组
System.out.println(array.length); // 输出: 3

实例：

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.打印


    }
}

通过方法引用，可以简化代码并提升可读性，尤其在Stream API和函数式编程中广泛应用。需注意目标方法的参数和返回值需与函数式接口匹配。

77tian
关注
Java阻塞队列解析：挑战并发编程中的瓶颈
曾经“等你生日那天”都遥远得像未来，如今却可欢愉的挥手说“下个十年见”
05-12 170万+
本文介绍了Java中的阻塞队列（BlockingQueue），重点讲解了其基本概念、常见实现及应用场景。通过分析生产者-消费者问题的解决方案，帮助开发者理解如何利用阻塞队列优化并发编程，提高系统效率与稳定性。
JAVA 8 方法引用
coderWang
08-30 321
一、什么是方法引用 方法引用提供了非常有用的语法，可以直接引用已有的java类或对象的方法或构造器。方法引用其实也离不开Lambda表达式，与lambda联合使用 ，方法引用可以使语言的构造更加紧凑简洁，减少冗余代码。 二、方法引用四种方式 类型 语法 对应lambda表达式 构造器引用 Class::new (args) -> new 类名(args) 静态方
JAVA8新特性之：方法引用
weixin_33947521的博客
12-07 254
2019独角兽企业重金招聘Python工程师标准>>> ...
Java8 方法引用
weixin_30877227的博客
01-07 124
概述 方法引用是用来直接访问类或实例阴茎存在的方法或者构造方法.它需要由兼容的函数式接口(lambda表达式中用到的接口)构成的目标类型上下文. 有时候, 当我们想要实现一个函数式接口的方法, 但是已经由类实现了我们想要的功能, 这时可以使用方法引用来直接使用现有的功能实现. 关于lambda表达式可以看这篇文章Java8 Lambda表达式 当lambda表达式只是执行一个方法调用时, 直...
30分钟入门Java8之方法引用
didingyun4257的博客
08-25 302
30分钟入门Java8之方法引用 前言 之前两篇文章分别介绍了Java8的lambda表达式和默认方法和静态接口方法。今天我们继续学习Java8的新语言特性——方法引用(Method References)。 在学习lambda表达式之后，我们通常使用lambda表达式来创建匿名方法。然而，有时候我们仅仅是调用了一个已存在的方法。如下: Arrays.sort(stringsArray...
Java 8之方法引用(Method References)
热门推荐
永无止境，上下求索
08-03 2万+
Java 8中方法也是一种对象，可以By名字来引用。不过方法引用的唯一用途是支持Lambda的简写，使用方法名称来表示Lambda。不能通过方法引用来或者诸如方法签名的相关信息。方法引用的分类方法引用分为4类，常用的是前两种。方法引用也受到访问控制权限的限制，可以通过在引用位置是否能够调用被引用方法来判断。具体分类信息如下： 引用静态方法 ContainingClass::staticMethod
精选资源
CompletableFuture：Java异步编程利器.pptx.pptx
12-21
CompletableFuture 是 Java 8 引入的重要特性，它扩展了 Future 接口，为开发者提供了强大的异步编程能力。CompletableFuture 不仅是非阻塞的，意味着在等待结果的同时，程序可以继续执行其他任务，提高了程序的并发...
《Java编程新利器：Lambda与Stream实战》
最新发布
09-01
内容概要：本文系统讲解了Java 8引入的两大核心特性——Lambda表达式与Stream API。首先介绍Lambda表达式的概念、语法结构及其在函数式接口中的应用，并结合Runnable、Consumer、Supplier、Function等常见函数式接口...
Groovy脚本：Java平台的动态编程利器
10-01
Groovy是一种运行在Java平台上的动态脚本语言，它与Java紧密集成，提供了一种简洁、灵活的方式来编写Java代码。Groovy不仅支持静态类型检查，还可以在运行时动态地编译和执行代码，这使得它在Java平台中的应用场景...
Java正则表达式：高效编程利器
与传统的编程方法相比，例如在验证电子邮件地址这类任务中，使用正则表达式可以简化代码量。传统编程可能需要编写冗长的逻辑来检查字符串格式，而在Java中，通过正则表达式，只需要寥寥几行代码即可完成相同的功能。...
JAVA8方法引用
weixin_45673552的博客
10-27 373
JDK8中引入了一种新的特性—方法引用（Method Reference），方法引用是Lambda的一种特例化形式，当Lambda表达式的主体部分只有一句，并且有一个特定的方法已经存在，那么可以使用方法引用来代替展示。 方法引用实际上是Lambda表达式的一种语法糖，所谓语法糖，就是并没有增加新的内容，只不过用一种更加简洁的形式来表现。 方法引用的分类： 类名::静态方法名 引用名（对象名）...
Java 8 方法引用
lihaizhou1234的博客
05-24 433
Java 8 方法引用形如 ClassName::methodName 或者 objectName::methodName 的表达式，我们把它叫做方法引用（Method Reference）。可能你现在还理解不了，但是编译器足够聪明，或许你可以看看编译器是如何根据 “晦涩难懂” 的 Method Reference 来推断你的意图的。方法引用的种类方法引用有四种，分别是：指向静态方法的引用指向某个...
Java 8 - 方法引用
qq_33240556的博客
07-27 526
方法引用是 Java 8 中引入的一种更简洁的 Lambda 表达式书写方式。方法引用允许你引用已经存在的类或对象的方法，而不是显式地定义一个 Lambda 表达式。这使得代码更加简洁和易于阅读。
W3Cschool Java 8新特性----> 方法引用
红叶岭谷的博客
05-18 490
方法引用通过方法的名字来指向一个方法。 方法引用可以使语言的构造更紧凑简洁，减少冗余代码。 方法引用使用一对冒号(::)。 下面，我们以定义了4个方法的Car这个类作为例子，区分Java中支持的4种不同的方法引用。public static class Car { public static Car create( final Supplier< Car > supplier ) {
java8简化的可变参数调用,Java8新特性--方法引用
weixin_32279911的博客
03-14 455
一.什么是方法引用？​ 谈到方法引用，就必须提到Lambda，因为方法引用是用在Lambda表达式的，方法引用是一种更简洁易懂的Lambda表达式，和Lambda表达式一样，也是一种语法糖。​ 当我们需要使用Lambda表达式来实现一个函数式接口的抽象方法时，已经有存在的类实现了我们需要的功能方法，这时我们完全没必要再造一个实现方法，可以直接用Lambda表达式调用这个方法来实现，虽然这样子实现可...
java 8新特性之方法引用
WangJQ12的博客
01-25 476
方法引用通过方法的名字来指向一个方法。 方法引用可以使语言的构造更紧凑简洁，减少冗余代码。 方法引用使用一对冒号 :: 。 下面，我们在 Car 类中定义了 4 个方法作为例子来区分 Java 中 4 种不同方法的引用。 public class Car { //Supplier是jdk1.8的接口，这里和lambda一起使用了 public static
java8 方法引用
qq_25825923
07-23 197
方法引用   我们先定义一个接口 (@FunctionalInterface  函数式接口:接口中只定义一个方法的接口称之为函数是接口) @FunctionalInterface public interface InterfaceLamdaFunction3 { void print(Integer t); } lambda表达式实现该接口 public class Tes...
Java8之方法引用
bmh228的博客
12-23 642
在Lambda表达式里，经常会有这样的代码artist -> artist.getName()就是lambda表达式里面调用了一个已存在的方法: getName() java8可以直接通过方法引用来简写lambda表达式中已经存在的方法，这种特性就叫方法引用。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值