数组引用，是 Lambda 针对数组的一种写法！

@FunctionalInterface
public interface Test {
    public void test();

    // public void test2();
}

【格式：】
    (参数列表) -> {Lambda 体};
注：
    参数列表指的是 方法的参数，即需要在 Lambda 体中执行的变量。
    Lambda 体指的是 方法体，定义了需要执行的功能。

【语法：】
    若出现一个参数的情况，可以将()省略。
    若出现一行代码的情况，可以将{}省略。
    对于多个参数的情况，可以省略参数类型（JVM 类型推断），但()不能省略。
    若{}中只有一行代码，且为return语句，则可省略return 和 {}。

【举例：】

/**
 * 测试 Lambda 表达式用法
 */
public class TestLambda {
    public static void main(String[] args) {
        String str = "helloworld";
        // 使用 匿名函数 时
        test(str, new TestLambdaFunction() {
            @Override
            public void test(String str) {
                System.out.println(str);
            }
        });

        // 使用 Lambda 表达式，此方法等价于上面匿名函数的写法
        // 只有一个参数，() 可省略，参数类型可省略（JVM自动进行类型推断）， Lambda 体只有一行代码，{} 可省略。
        test(str, x -> System.out.println(x));
    }

    public static void test(String str, TestLambdaFunction testLambdaFunction) {
        testLambdaFunction.test(str);
    }
}

@FunctionalInterface
interface TestLambdaFunction {
    void test(String str);
}

【四大核心函数式接口：（其余函数式接口用法类似）】
    Consumer<T>          消费型接口，有参数 T，没有返回值。
        抽象方法： void accept(T t);

    Supplier<T>              供给型接口，没有参数，有返回值 T。
        抽象方法： T get();  

    Function<T, R>         函数型接口，有参数 T，有返回值 R。
        抽象方法：R apply(T var1);
    
    Predicate<T>             断言型接口，有参数 T，返回值为 boolean 型。
        抽象方法： boolean test(T var1);


【举例：】

import java.util.Date;
import java.util.function.Consumer;
import java.util.function.Supplier;

/**
 * 测试 Lambda 表达式用法
 */
public class TestLambda {
    public static void main(String[] args) {
        String str = "helloworld";
        // 测试 Consumer<T> 函数式接口，此处定义 Consumer<T> 函数式接口抽象方法的具体实现
        testConsumer(str, x -> System.out.println(x));

        // 测试 Supplier<T> 函数式接口，此处定义 Supplier<T> 函数式接口抽象方法的具体实现
        testSupplier(() -> new Date());
    }

    public static void testConsumer(String str, Consumer<String> consumer) {
        // 此处为 Consumer<T> 函数式接口抽象方法具体调用
        consumer.accept(str);
    }

    public static void testSupplier(Supplier<Date> supplier) {
        // 此处为 Supplier<T> 函数式接口抽象方法具体调用
        System.out.println(supplier.get());
    }
}

【格式：】
    对象名::实例方法名
    类名::静态方法名
    类名::实例方法名   
注：
    方法引用 的方法与函数式接口中的方法 返回值类型 以及 参数类型要一致。
    当 Lambda 参数列表中 第一个参数 是实例方法的调用者，第二个参数是 实例方法的参数时，才可以使用 类::实例方法名。 比如:String::equals.
    
【举例：】

import java.io.PrintStream;
import java.util.function.Consumer;

/**
 * 测试 Lambda 表达式用法
 */
public class TestLambda {
    public static void main(String[] args) {
        Consumer<String> consumer0 = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        consumer0.accept("匿名函数");

        // 一般 Lambda 表达式写法
        Consumer<String> consumer1 = x -> System.out.println(x);
        consumer1.accept("hello");

        PrintStream printStream = System.out;

        Consumer<String> consumer2 = x -> printStream.println(x);
        consumer2.accept("hello wrold");

        // 使用 对象名::实例方法名 去改写 Lambda 表达式，本质与 Lambda 表达式一致
        Consumer<String> consumer3 = printStream::println;
        consumer3.accept("world");
    }
}

【格式：】
    类名::new
注：
    构造器引用 的参数列表 与 函数式接口中方法的参数列表 要一致。
    即通过方法参数去确认调用哪一个构造方法。

【举例：】

import java.util.function.Function;

/**
 * 测试 Lambda 表达式用法
 */
public class TestLambda {
    public static void main(String[] args) {
        // 普通 Lambda 表达式
        Function<String, String> function = (x) -> new String(x).trim();
        System.out.println(function.apply("       ddd hello "));

        // Lambda 表达式 -- 构造器引用
        Function<String, String> function1 = String::new;
        System.out.println(function1.apply("      hello "));

        // 普通 Lambda 表达式，并创建一个对象实例，等价于 上面的构造器引用
        Function<String, String> function2 = (x) -> new String(x);
        System.out.println(function2.apply("      hello "));
    }
}

【格式：】
    数组类型[]::new

【举例：】

import java.util.function.Function;

/**
 * 测试 Lambda 表达式用法
 */
public class TestLambda {
    public static void main(String[] args) {
        // 一般 Lambda 创建一个数组的写法
        Function<Integer, String[]> function = x -> new String[x];
        System.out.println(function.apply(10).length);

        // 使用数组引用创建一个 数组的写法
        Function<Integer, String[]> function1 = String[]::new;
        System.out.println(function1.apply(20).length);
    }
}