方法引用与构造器引用

方法引用：

package com.atguigu.java3;
import org.junit.Test;
import java.io.PrintStream;
import java.util.Comparator;
import java.util.function.BiPredicate;
import java.util.function.Consumer;
import java.util.function.Function;
/**
 * 方法的引用的使用
 * <p>
 * 1.使用情景：当要传递给Lambda体的操作，已经有实现的方法了，可以使用方法引用！
 * <p>
 * 2.方法引用，本质上就是Lambda表达式，而Lambda表达式作为函数式接口的实例。所以
 * 方法引用，也是函数式接口的实例。
 * <p>
 * 3.使用格式：  类(或对象) :: 方法名
 * <p>
 * 4.具体分为如下三种情况：
 * 情况一     对象 ::  非静态方法
 * 情况二     类   ::  静态方法
 * 情况三     类   ::  非静态方法
 * <p>
 * 5.方法引用使用的要求：要求接口中的抽象方法的形参列表和返回值类型与方法引用的方法的
 * 形参列表和返回值类型相同（针对于情况1 和 情况2）
 *
 * @author Dxkstart
 * @create 2021-06-09 11:29
 */
public class MethodRefTest {
    //情况一：对象::实例方法
    //Consumer中的void accept(T t)
    //PrintStream中的void println(T t)
    @Test
    public void test1() {
        Consumer<String> con1 = str -> System.out.println(str);
        con1.accept("北京");
        System.out.println("******************************");
        PrintStream ps = System.out;
        Consumer<String> con2 = ps::println;
        con2.accept("beijing");
    }
    //Supplier中的T get（）
    //Employee中的String getName()
    //情况二：类 :: 静态方法
    //Comparator中的int compare(T t1,T t2)
    //Integer中的int compare(T t1,T t2)
    @Test
    public void test3() {
        Comparator<Integer> com1 = (t1, t2) -> Integer.compare(t1, t2);
        System.out.println(com1.compare(12, 32));
        System.out.println("******************************");
        Comparator<Integer> com2 = Integer::compare;
        System.out.println(com2.compare(12, 3));
    }
    //Function中的R apply(T t)
    //Math中的Long round(Double d)
    @Test
    public void test4() {
        Function<Double, Long> func = new Function<Double, Long>() {
            @Override
            public Long apply(Double d) {
                return Math.round(d);
            }
        };
        System.out.println("******************************");
        Function<Double, Long> func1 = d -> Math.round(d);
        System.out.println(func1.apply(12.3));
        System.out.println("******************************");
        Function<Double, Long> func2 = Math::round;
        System.out.println(func1.apply(12.7));
    }
    //情况三：类 :: 实例方法 (有难度)
    //Comparator中的int compare(T t1,T t2)
    //String中的int t1.compareTo(t2)
    @Test
    public void test5() {
        Comparator<String> com1 = (s1, s2) -> s1.compareTo(s2);
        System.out.println(com1.compare("abc", "abd"));
        System.out.println("******************************");
        Comparator<String> com2 = String::compareTo;
        System.out.println(com2.compare("abc", "abm"));
    }
    //BiPredicate中的boolean test(T t1,T t2);
    //String中的boolean t1.equals(t2)
    @Test
    public void test6() {
        BiPredicate<String, String> pre1 = (s1, s2) -> s1.equals(s2);
        System.out.println(pre1.test("abc", "abc"));
        System.out.println("******************************");
        BiPredicate<String, String> pre2 = String::equals;
        System.out.println(pre1.test("abc", "abd"));
    }
    //Function中的R apply(T t)
    //Employee中的String getName();
    @Test
    public void test7() {
    }
}

构造器引用

package com.atguigu.java3;
import org.junit.Test;
import java.util.Arrays;
import java.util.function.Function;
import java.util.function.Supplier;
/**
 * 一、构造器引用
 *        和方法引用类似，函数式接口的抽象方法的形参列表和构造器的形参列表一致。
 *        抽象方法的返回值类型即为构造器所属的类的类型
 *
 *
 * 二、数组引用
 *       大家可以把数组看做是一个特殊的类，则写法与构造器引用一致。
 *
 *
 * @author Dxkstart
 * @create 2021-06-09 12:23
 */
public class ConstructorTest {
    //构造器引用
    //Supplier中的T get()
    @Test
    public void test1(){
        Supplier<Employee> sup = new Supplier<Employee>() {
            @Override
            public Employee get() {
                return new Employee();
            }
        };
        System.out.println(sup.get());
        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());
    }
    //Function中的R apply(T t)
    @Test
    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);
    }
    //两个参数的
    //BiFunction中的R apply(T t,U u)
    @Test
    public void test3(){
//        BiFunction<Integer,String,Employee> func1 = (id,name) -> new Employee(id,name);
//        System.out.println(func1.apply(1001,"Tom"));
        System.out.println("****************");
//        BiFunction<Integer,String,Employee> func2 = Employee :: new;
//        System.out.println(func2.apply(1002,"Jim"));
    }
    //数组引用
    //Function中的R apply(T t)
    @Test
    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 = func1.apply(10);
        System.out.println(Arrays.toString(arr2));
    }
}