方法引用与构造器引用

1.方法引用( Metrod references)

• 当要传递给 Lambda体的操作,已经有实现的方法了,可以使用方法引用!
• 方法引用可以看做是 Lambda表达式深层次的表达。换句话说,方法引用就是 Lambda表达式,也就是函数式接口的一个实例,通过方法的名字来指向一个方法,可以认为是 Lambda表达式的一个语法糖
• 格式:使用操作符“::”将类(或对象)与方法名分隔开来
• 如下三种主要使用情况

情况1 对象::实例方法名
>情况2 类∷静态方法名
>情况3 类::实例方法名

• 方法引用使用的要求:实现接口的抽象方法的参数列表和返回值类型,必须与方法引用的方法的参数列表和返回值类型保持一致(针对于情况1和情况2)

情况一: 对象 :: 实例方法

public class MethodRefTest {
    //情况一: 对象 :: 实例方法
    //Consumer中的void accept(T t)
    //PrintStream中的void println(T t)
    public void test1(){
        Consumer<String> con1 = str -> System.out.println(str);
        con1.accept("杭州");
        //------------------
        Consumer<String> con2 = System.out :: println;
        con2.accept("hangzhou");
    }
}

情况二: 类 :: 静态方法

public class MethodRefTest {
    //情况二: 类 :: 静态方法
    //Consumer中的int compare(T t1,T t2)
    //Integer中的int compare(T t1,T t2)
    public void test2(){
        Comparator<Integer> com1 = (t1,t2) -> Integer.compare(t1,t2);
        System.out.println(com1.compare(12, 21));

        //---------------
        Comparator<Integer> com2 = Integer::compareTo;
        System.out.println(com2.compare(12, 2));
    }
}

情况三: 类 :: 实例方法

public class MethodRefTest {
    //情况三: 类 :: 实例方法
    //Consumer中的int compare(T t1,T t2)
    //String中的int t1.compareTo(t2)
    public void test3(){
        Comparator<String> com1 = (s1,s2) -> s1.compareTo(s2);
        System.out.println(com1.compare("abc", "bcd"));

        //---------------
        Comparator<String> com2 = String ::compareTo;
        System.out.println(com2.compare("abc", "abc"));
    }
}

2.构造器引用

a.构造器引用

和方法引用类似, 函数式接口的抽象方法的形参列表和构造器的形参列表一致.
抽象方法的返回值即为构造器所属的类的类型

public class ConstructorRefTest {

    //构造器引用
    //Supplier中的T get()
    //Employee的空参构造器 : Employee()
    public void test1(){
        Supplier<Employee> sup = new Supplier<Employee>() {
            @Override
            public Employee get() {
                return new Employee();
            }
        };
        System.out.println("**************");
        Supplier<Employee> sup1 = () -> new Employee();
        System.out.println(sup1.get());

        System.out.println("**************");
        Supplier<Employee> sup2 = Employee :: new;
        System.out.println(sup2.get());
    }

    public void test2(){
        Function<Integer,Employee> func1 = id -> new Employee(id);
        Employee employee = func1.apply(1001);
        System.out.println(employee);

        System.out.println("**************");
        Function<Integer,Employee> func2 = Employee::new;
        Employee employee1 = func2.apply(1002);
        System.out.println(employee1);
    }
}

b.数组引用

可以将数组看作是一个特殊的类,则写法与构造器一致了

    //数组引用
    //Function中的R apply(T t)
    public void test4(){
        Function<Integer, String[]> func1 = length -> new String[length];
        String[] arr1 = func1.apply(5);
        System.out.println(Arrays.toString(arr1));

        System.out.println("*****************");
        Function<Integer, String[]> func2 = String[]::new;
        String[] arr2 = func2.apply(10);
        System.out.println(Arrays.toString(arr2));

    }