Java8笔记第四篇（ 方法引用与构造器引用）

目录：
第一篇：初探 java8 第 01 篇（ Lambda与Stream API初识 ）
第二篇：深入 java8 第 02 篇（ Lambda表达式基础语法 ）
第三篇：深入 java8 第 03 篇（ 函数式接口，常见的4个函数式接口 ）
第四篇：深入 java8 第 04 篇（ 方法引用与构造器引用 ）
第五篇：深入 java8 第 05 篇（ Stream API 的操作->创建及中间操作 ）
第六篇：深入 java8 第 06 篇（ Stream API 的操作->终止操作 ）
第七篇：深入 java8 第 07 篇（ Stream API 的操作->规约、收集 ）
第八篇：深入 java8 第 08 篇（ Stream API 的综合练习 ）
第九篇：深入 java8 第 09 篇（ Fork/Join 框架的使用及其优势 ）
第十篇：深入 java8 第 10 篇（ 时间新特新 -> DateTimeFormatter 解析与格式化 ）
第十一篇：深入 java8 第 11 篇（ 带时区的时间或日期）
第十二篇：深入 java8 第 12 篇（接口中的默认方法与静态方法 ）
第十三篇：深入 java8 第 13 篇（ 其他新特性 -> Optional 类/重复注解与类型注解 ）

方法引用与构造器引用

一、方法引用：若 Lambda 体中的功能，已经有方法提供了实现，可以使用方法引用
（可以将方法引用理解为 Lambda 表达式的另外一种表现形式）

1. 对象的引用 :: 实例方法名

2. 类名 :: 静态方法名

3. 类名 :: 实例方法名

注意：
①方法引用所引用的方法的参数列表与返回值类型，需要与函数式接口中抽象方法的参数列表和返回值类型保持一致！
②若Lambda 的参数列表的第一个参数，是实例方法的调用者，第二个参数(或无参)是实例方法的参数时，格式： ClassName::MethodName

二、构造器引用 :构造器的参数列表，需要与函数式接口中参数列表保持一致！

1. 类名 :: new

三、数组引用

类型[] :: new;

4.1 方法引用
4.1.1 对象的引用 :: 实例方法名

@Test
    public void test01(){
        // 传统的方法调用
        PrintStream out = System.out;
        Consumer<Integer> consumer1 = (num) -> out.println(num);
        consumer1.accept(6666);

        // 现在的方法引用
        Consumer<Integer> consumer2 = out::println;
        consumer2.accept(6666);
    }

    @Test
    public void test02(){
        // 传统的方法调用
        Employee emp = new Employee(1001, "huazai", 28, 18000.00, Status.BUSY);
        Supplier<Double> sup = () -> emp.getSalary();
        System.out.println("本月实发工资："+sup.get()+"$");

        // 现在的方法引用
        Supplier<String> sup2 = emp::getName;
        System.out.println("\n本月获奖者员工姓名："+sup2.get());
    }

4.1.2 类名 :: 静态方法名

@Test
    public void test03(){
        // 传统的方法调用
        BiFunction<Integer, Integer, Integer> biFunction = (x,y)->Math.floorDiv(x, y);
        Integer result = biFunction.apply(500, 100);
        System.out.println(result);

        // 现在的方法引用
        BiFunction<Integer, Integer, Integer> biFunction2 = Math::floorDiv;
        Integer result2 = biFunction2.apply(300, 200);
        System.out.println(result2);
    }

    @Test
    public void test04(){
        // 传统的方法调用 1：表示x大于y，-1：表示x小于y
        Comparator<Integer> comparator = (x,y) -> Integer.compare(x, y);
        int i = comparator.compare(100, 99);
        System.out.println(i);

        // 现在的方法引用
        Comparator<Integer> comparator2 = Integer::compare;
        int ii = comparator2.compare(100, 199);
        System.out.println("\n"+ii);
    }

4.1.3 类名 :: 实例方法名

@Test
    public void test05(){
        // 传统的方法调用
        BiPredicate<String, String> biPredicate = (x,y) -> x.equals(y);
        System.out.println(biPredicate.test("AAA", "AAA"));

        // 现在的方法引用
        BiPredicate<String, String> biPredicate2 = String::equals;
        System.out.println("\n"+biPredicate2.test("aa", "aaa"));

        // 传统的方法调用
        Function<Employee, String> function = (e)->e.print();
        System.out.println("\n"+function.apply(new Employee()));

        // 现在的方法引用
        Function<Employee,String> function2 = Employee::print;
        System.out.println("\n"+function2.apply(new Employee()));
    }

4.2 构造器引用
4.2.1 类名 :: new

@Test
    public void test06(){
        // 传统的构造器引用
        Supplier<Employee> supplier = () -> new Employee();
        System.out.println(supplier.get());

        // 现在的构造器引用
        Supplier<Employee> supplier2 = Employee::new;
        System.out.println("\n"+supplier2.get());
    }

    @Test
    public void test07(){
        Function<String, Employee> function = Employee::new;
        System.out.println(function.apply("huazai"));

        BiFunction<Integer, String, Employee> function2 = Employee::new;
        System.out.println("\n"+function2.apply(1001, "huazai"));
    }

4.3 数组引用
4.3.1 类型[] :: new;

@Test
    public void test08(){
        // 传统的数组引用
        Function<Integer, String[]> function = (num) -> new String[num];
        String[] apply = function.apply(10);
        System.out.println("数组长度："+apply.length);

        // 现在的数组引用
        Function<Integer, String[]> function2 = String[]::new;
        String[] apply2 = function2.apply(20);
        System.out.println("\n数组长度："+apply2.length);
    }

    @Test
    public void test09(){
        // 传统的数组引用
        Function<Integer, Employee[]> function = (num) -> new Employee[num];
        Employee[] employees = function.apply(10);
        System.out.println("数组长度"+employees.length);

        // 现在的数组引用
        Function<Integer, Employee[]> function2 = Employee[]::new;
        Employee[] employees2 = function2.apply(20);
        System.out.println("\n数组长度"+employees2.length);
    }

源码下载地址：https://download.csdn.net/download/hello_world_qwp/10401249