方法引用

• 当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用！ （实现抽象方法的参数列表，必须与方法引用方法的参数列表保持一致！）
• 方法引用：使用操作符 “ **:: **” 将方法名和对象或类的名字分隔开来。 如下三种主要使用情况：
• 当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用！ （实现抽象方法的参数列表，必须与方法引用方法的参数列表保持一致！） 方法引用：使用操作符 “::” 将方法名和对象或类的名字分隔开来。 如下三种主要使用情况： * 对象::实例方法 * 类::静态方法 * 类::实例方法

 构造器引用

格式：ClassName::new 与函数式接口相结合，自动与函数式接口中方法兼容。 可以把构造器引用赋值给定义的方法，与构造器参数 列表要与接口中抽象方法的参数列表一致！

数组引用

格式： type[] :: new

代码演示

package com.www.java8.test;

import com.www.java8.entity.Employee;
import org.testng.annotations.Test;

import java.io.PrintStream;
import java.util.Comparator;
import java.util.function.*;

/**
 * 一 、方法引用 ：若 ：Lambda 体中 的内容有方法已经实现了， 我们可以使用 “ 方法引用 ”
 * <p>
 * 主要有三种 语法格式
 * <p>
 * 对象 :: 实列方法名
 * <p>
 * 类 :: 静态方法名
 * <p>
 * 类 :: 实例方法名
 * <p>
 * 注意 ：
 * <p>
 * Lambda 体中调用方法的参数列表与返回值类型，要与函数式接口中的抽象方法的函数列表和返回值类型  保持一致
 * <p>
 * 若 第一个参数的实列方法的调用者，第二个方法是实列方法的参数时 可以使用 ClassName:: method
 * <p>
 * <p>
 * <p>
 * 二 、 构造器引用
 * <p>
 * 格式
 * ClassName :: new
 * <p>
 * 注意 ： 需要调用的构造器的参数列表与函数是接口中抽象方法的参数列表保持一致！
 * <p>
 * <p>
 * <p>
 * 三 、 数组引用
 * Type :: new
 *
 * @author Www
 * <p>
 * 邮箱： 483223455@qq.com
 * <p>
 * 创建时间: 2022/8/12  14:35  星期五
 * <p>
 */
public class Lambda3Test {
    
    /**
     * 对象 :: 实列方法名
     */
    @Test
    public void test1() {
        PrintStream out = System.out;
        Consumer<String> consumer = (x) -> out.println(x);
        PrintStream out1 = System.out;
        Consumer<String> consumer1 = out::println;
        Consumer<String> consumer2 = System.out::println;
        consumer2.accept("hello world");
    }
    
    @Test
    public void test2() {
        Employee employee = new Employee();
        employee.setName("张三");
        employee.setAge(23);
        Supplier<String> supplier = () -> employee.getName();
        String s = supplier.get();
        System.out.println(s);
        Supplier<Integer> supplier1 = employee::getAge;
        Integer integer = supplier1.get();
        System.out.println(integer);
    }
    
    /**
     * 类 :: 静态方法名
     */
    @Test
    public void test3() {
        Comparator<Integer> com = (x, y) -> Integer.compare(x, y);
        // 第一个参数的实列方法的调用者，第二个方法是实列方法的参数
        Comparator<Integer> comparator = Integer::compare;
    }
    
    /**
     * 类 :: 实列方法名
     */
    @Test
    public void test4() {
        BiPredicate<String, String> predicate = (x, y) -> x.equals(y);
        System.out.println(predicate);
    }
    
    
    /**
     * 构造器引用
     * <p>
     * ClassName :: new
     */
    @Test
    public void test5() {
        Supplier<Employee> supplier = () -> new Employee();
        Supplier<Employee> supplier2 = Employee::new;
        Employee employee = supplier2.get();
        System.out.println(employee);
    }
    
    /**
     * 带参数的构造器
     */
    @Test
    public void test6() {
        Function<Integer, Employee> function = (x) -> new Employee(x);
        Function<Integer, Employee> function2 = Employee::new;
        Employee apply = function2.apply(21);
        System.out.println(apply);
        BiFunction<Integer, String, Employee> function3 = Employee::new;
        Employee apply1 = function3.apply(12, "2332");
        System.out.println(apply1);
    }
    
    /**
     * 数组引用
     */
    @Test
    public void test7() {
        Function<Integer, Integer[]> function = (x) -> new Integer[x];
        Integer[] apply = function.apply(20);
        System.out.println(apply.length);
        Function<Integer, String[]> function1 = String[]::new;
        String[] apply1 = function1.apply(30);
        System.out.println(apply1.length);
    }
}