Java033——方法的引用

一、Java方法引用说明

Java方法引用是一种简化Lambda表达式的语法，它允许直接通过方法的名称来引用已经存在的方法，而不是定义Lambda表达式。方法引用可以使代码更简洁、易读，并提高可维护性

二、Java中的方法引用的四种形式

2.1、引用静态方法

引用静态方法的语法如下:

类名::静态方法名

1、这个语法中出现了一个新的操作符“::”，这是由两个英文冒号组成的操作符，冒号之间没有空格。
2、这个操作符左边表示方法所属的类名，右边是方法名。
3、需要注意的是，这个语法中方法名是没有圆括号的。

interface StaticMethodInterface { 							// 测试接口
    int method(int a, int b);  								// 抽象方法
}

public class StaticMethodDemo{
    static int add(int x, int y) {								// 静态方法，返回两个参数相加的结果
        return x + y;                         					//返回相加结果
    }

    public static void main(String[] args) {
    	//语法： 类名::静态方法名
        StaticMethodInterface sm = StaticMethodDemo::add; 		//引用StaticMethodDemo类的静态方法
        int result = sm.method(15, 16);							//直接调用接口方法获取结果
        System.out.println("接口方法结果：" + result); 			//输出结果
    }
}

//运行结果
接口方法结果: 31

2.2、引用成员方法

语法如下:

对象名::成员方法名

与引用静态方法语法不同，这里操作符左侧的必须是一个对象名，而不是类名。这种语法也可以达到抽象方法按照类成员方法逻辑来实现的目的。

interface InstanceMethodInterface {                    // 创建测试接口
    String method(Date date);                           // 带参数的抽象方法
}

class TestDemo {
    public String format(Date date) {                  // 格式化方法
        // 创建日期格式化对象，并指定日期格式
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        return sdf.format(date);                       // 返回格式化结果
    }

    public static void main(String[] args) {
        // 创建类对象
        TestDemo demo = new TestDemo ();
        // 引用类对象的方法
        InstanceMethodInterface im = demo::format;
        Date date = new Date();                       // 创建日期对象
        System.out.println("默认格式：" + date);     	// 输出日期对象默认格式
        // 输出经过接口方法处理过的格式
        System.out.println("接口输出的格式：" + im.method(date));
    }
}

//运行结果
默认格式：Fri Jul 14 22:40:40 CST 2023
接口输出的格式：2023-07-14

2.3、引用构造方法

2.3.1、引用无参构造方法

引用构造方法的语法如下:

类名::new

class TestDemo {
    public TestDemo() { // 无参构造方法
        System.out.println("调用无参构造方法");
    }

    public TestDemo(int i) { // 有参构造方法
        System.out.println("调用有参构造方法");
    }

    public static void main(String[] args) {
        // 引用ConstructorsTest1类的构造方法
        ConstructorsInterface1 a = TestDemo::new;
        TestDemo b = a.action(); // 通过无参方法创建对象

    }
}

//运行结果
调用无参构造方法

2.3.2、引用有参构造方法

引用有参构造方法的语法与引用无参构造方法一样。区别就是函数式接口的抽象方法是有参数的。

class TestDemo {
    public TestDemo() { // 无参构造方法
        System.out.println("调用无参构造方法");
    }

    public TestDemo(int i) { // 有参构造方法
        System.out.println("调用有参构造方法，参数为：" + i);
    }

    public static void main(String[] args) {
        // 引用ConstructorsTest1类的构造方法
        ConstructorsInterface1 a = TestDemo::new;
        TestDemo b = a.action(5688); // 通过无参方法创建对象

    }
}

//运行结果
调用有参构造方法，参数为：5688

2.3.3、 引用数组构造方法

语法如下:

类名()::new

创建函数式接口和测试类。定义接口时创建一个泛型 T，同时 T 作为抽象方法的返回值。抽象方法定义一个整型参数。创建接口对象时，将测试类数组作为泛型，并引用数组构造方法。通过接口方法创建测试类数组，再分别为每个数组元素赋值。

interface ArraysConsInterface<T> {                   // 构造方法接口
    // 抽象方法返回对象数组，方法参数决定数组个数
    T action(int n);
}

class TestDemo {
    public static void main(String[] args) {
        // 引用数组的构造方法
        ArraysConsInterface<TestDemo[]> a = TestDemo[]::new;
        TestDemo array[] = a.action(3);      // 接口创建数组，并指定数组个数
        array[0] = new TestDemo();           // 给数组元素实例化
        array[1] = new TestDemo();
        array[2] = new TestDemo();
        // 如果调用或给array[3]赋值，代码则会抛出数组下标越界异常
        // array[3] = new ArraysConsDemo();
    }
}

2.4、引用特定类型的实例方法：

语法如下:

特定对象::方法名。

// 示例：引用ArrayList实例的size方法
List<String> list = new ArrayList<>();
Supplier<Integer> sup = list::size;

2.4.1、引用带泛型的方法

import java.util.HashSet;
interface ParadigmInterface<T> {                           // 测试接口
    int method(T[] t);                                      // 抽象方法
}

public class ParadigmDemo {// 测试类
    // 静态方法，使用泛型参数，在方法名之前定义泛型。此方法用于查找数组中的重复元素个数
    static public <T> int repeatCoount(T[] t) {
        int arrayLength = t.length;                     	// 记录数组长度
        java.util.HashSet<T> set = new HashSet<>(); 		// 创建哈希集合
        for (T tmp : t) {                        			// 遍历数组
            set.add(tmp);  							// 将数组元素放入集合中
        }
        return arrayLength - set.size();                    // 返回数组长度与集合长度的差
    }

    public static void main(String[] args) {
        Integer a[] = {1, 1, 2, 3, 1, 5, 6, 1, 8, 8};   			// 整数数组
        
        String s[] = {"王", "李", "赵", "陈", "李", "孙", "张"};		// 字符串数组
        // 创建接口对象，Integer作为泛型，引入ParadigmDemo类的静态方法,方法名要定义泛型
        ParadigmInterface<Integer> p1 = ParadigmDemo::<Integer> repeatCoount;
        // 调用接口方法
        System.out.println("整数数组重复元素个数：" + p1.method(a));
        // 创建接口对象，String作为泛型，引入ParadigmDemo类的静态方法
 		// 方法名若不定义泛型，则默认使用接口已定义好的的泛型
        ParadigmInterface<String> p2 = ParadigmDemo::repeatCoount;
        // 调用接口对象方法
        System.out.println("字符串数组重复元素个数：" + p2.method(s));
    }
}

//运行结果
整数数组重复元素个数：4
字符串数组重复元素个数：1