Java中的方法引用、构造器引用和数组引用

在Java 8中，除了引入Lambda表达式外，还引入了方法引用、构造器引用和数组引用。这些引用为我们提供了一种更简洁的语法来引用现有的方法、构造器和数组，从而使代码更加简洁和可读。

一、方法引用

1.1 什么是方法引用？

方法引用是一种更简洁的Lambda表达式写法，它可以直接引用已有的方法，避免了Lambda表达式中显式定义方法体的繁琐。方法引用使用 :: 操作符。

1.2 方法引用的四种形式

1.2.1 静态方法引用

格式：类名::静态方法名

示例：

// Lambda表达式写法
Function<Integer, String> func = num -> String.valueOf(num);

// 方法引用写法
Function<Integer, String> func = String::valueOf;

System.out.println(func.apply(123)); // 输出：123

1.2.2 实例方法引用

格式：实例对象::实例方法名

示例：

// Lambda表达式写法
Consumer<String> consumer = str -> System.out.println(str);

// 方法引用写法
Consumer<String> consumer = System.out::println;

consumer.accept("Hello, Method Reference!"); // 输出：Hello, Method Reference!

1.2.3 对象方法引用

格式：类名::实例方法名

示例：

// Lambda表达式写法
BiPredicate<String, String> predicate = (str1, str2) -> str1.equals(str2);

// 方法引用写法
BiPredicate<String, String> predicate = String::equals;

System.out.println(predicate.test("test", "test")); // 输出：true

二、构造器引用

构造器引用是方法引用的一种特殊形式，它用于引用类的构造方法。

2.1 无参构造器引用

示例：

// Lambda表达式写法
Supplier<Person> supplier = () -> new Person();

// 构造器引用写法
Supplier<Person> supplier = Person::new;

Person person = supplier.get();

2.2 带参构造器引用

示例：

// Lambda表达式写法
Function<String, Person> function = name -> new Person(name);
BiFunction<String, Integer, Person> function2 = (name, age) -> new Person(name, age);

// 构造器引用写法
Function<String, Person> function = Person::new;
BiFunction<String, Integer, Person> function2 = Person::new;

Person person1 = function.apply("John");
Person person2 = function2.apply("John", 12);

三、数组引用

数组引用是一种特殊形式的构造器引用，用于创建数组对象。

3.1 数组引用的使用

示例：

// Lambda表达式写法
Function<Integer, String[]> function = size -> new String[size];

// 数组引用写法
Function<Integer, String[]> function = String[]::new;

String[] array = function.apply(10);
System.out.println(array.length); // 输出：10

四、综合示例

为了更好地理解方法引用、构造器引用和数组引用，我们来看一个综合示例：

import java.util.function.*;

public class ReferenceExample {
    public static void main(String[] args) {
        // 静态方法引用
        Function<Integer, String> staticMethodRef = String::valueOf;
        System.out.println(staticMethodRef.apply(123)); // 输出：123

        // 实例方法引用
        Consumer<String> instanceMethodRef = System.out::println;
        instanceMethodRef.accept("Hello, Method Reference!"); // 输出：Hello, Method Reference!

        // 对象方法引用
        BiPredicate<String, String> objectMethodRef = String::equals;
        System.out.println(objectMethodRef.test("test", "test")); // 输出：true

        // 无参构造器引用
        Supplier<Person> noArgConstructorRef = Person::new;
        Person person1 = noArgConstructorRef.get();

        // 带参构造器引用
        Function<String, Person> argConstructorRef = Person::new;
        BiFunction<String, Integer, Person> argConstructorRef2 = Person::new;
        Person person2 = argConstructorRef.apply("John");
        Person person3 = argConstructorRef2.apply("John", 12);

        // 数组引用
        Function<Integer, String[]> arrayRef = String[]::new;
        String[] array = arrayRef.apply(10);
        System.out.println(array.length); // 输出：10
    }
}

class Person {
    private String name;
    private int age;

    public Person() {
        this.name = "Unknown";
    }

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

    @Override
    public String toString() {
        return "Person{name='" + name + "', age=" + age + '}';
    }
}