函数式接口的实例-构造器引用-数组引用

package com.lambda;

/**
 * @author 21115 @ date 2021/9/8
 */
public class Employee {

    private int id;
    private String name;
    private int age;
    private double salary;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public double getSalary() {
        return salary;
    }

    public void setSalary(double salary) {
        this.salary = salary;
    }

    public Employee() {}

    public Employee(int id) {
        this.id = id;
    }

    public Employee(int id, String name) {
        this.id = id;
        this.name = name;
    }

    public Employee(int id, String name, int age, double salary) {
        this.id = id;
        this.name = name;
        this.age = age;
        this.salary = salary;
    }

    @Override
    public String toString() {
        return "Employee{" + "id=" + id + ", name='" + name + '\'' + ", age=" + age + ", salary=" + salary + '}';
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }
        if (o == null || getClass() != o.getClass()) {
            return false;
        }

        Employee employee = (Employee)o;

        if (id != employee.id) {
            return false;
        }
        if (age != employee.age) {
            return false;
        }
        if (Double.compare(employee.salary, salary) != 0) {
            return false;
        }
        return name != null ? name.equals(employee.name) : employee.name == null;
    }

    @Override
    public int hashCode() {
        int result;
        long temp;
        result = id;
        result = 31 * result + (name != null ? name.hashCode() : 0);
        result = 31 * result + age;
        temp = Double.doubleToLongBits(salary);
        result = 31 * result + (int)(temp ^ (temp >>> 32));
        return result;
    }
}

package com.lambda;

import java.io.PrintStream;
import java.util.Comparator;
import java.util.function.BiPredicate;
import java.util.function.Consumer;
import java.util.function.Function;

import org.junit.Test;

/**
 * 1.使用情景：当要换递给 Lambda 体的操作，已经有实现的方法了，可以使用方法引用！
 * 
 * 2.方法引用，本质上就是 Lambda 表达式，而 Lambda 表达式作为函数式接口的实例。
 * 
 * ..所以方法引用，也是函数式接口的实例。
 * 
 * 3.使用格式：类(或对象) :: 方法名
 * 
 * 4.具体分为如下的三种情况：
 * 
 * ..情况1 对象 :: 非静态方法(不能 对象 :: 静态方法)
 * 
 * ..情况2 类 :: 静态方法
 * 
 * ..情况3 类 :: 非静态方法
 * 
 * 5.方法引用使用的要求：要求接口中的抽象方法的形参列表和返回值类型与方法引用的方法的
 * 
 * 。。形参列表和返回值类型相同！(针对于 情况1 和 情况2)
 * 
 * 
 */
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");
        // 北京
        // *** *** *** *** ***
        // beijing
    }

    // Supplier 中的 T get()
    // Employee 中的 String getName()
    @Test
    public void test2() {
        // Employee emp = new Employee(1001, "Tom", 23, 5600);
        //
        // Supplier<String> sup1 = () -> emp.getName();
        // System.out.println(sup1.get());
        //
        // System.out.println("*** *** *** *** ***");
        // Supplier<String> sup2 = emp::getName;
        // System.out.println(sup2.get());
        // // Tom
        // // *** *** *** *** ***
        // // Tom
    }

    // 情况二：类 :: 静态方法
    // 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, 21));

        System.out.println("*****************");

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

    // 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(func2.apply(12.6));
        // **********************
        // 12
        // **********************
        // 13
    }

    // 情况三：类 :: 实例方法 (有难度)
    // Comparator 中的 int comapre(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("abd", "abm"));
        // -1
        // ********************
        // -9
    }

    // 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(pre2.test("abc", "abd"));
        // true
        // *******************
        // false
    }

    // Function 中的 R apply(T t)
    // Employee 中的 String getName();
    @Test
    public void test7() {
        // Employee employee = new Employee(1001, "Jerry", 23, 6000);
        //
        // Function<Employee, String> func1 = e -> e.getName();
        // System.out.println(func1.apply(employee));
        //
        // System.out.println("********************");
        //
        // Function<Employee, String> func2 = Employee::getName;
        // System.out.println(func2.apply(employee));

        // Jerry
        // *******************
        // Jerry
    }
}

package com.lambda;

import java.util.Arrays;
import java.util.function.Function;

import org.junit.Test;

/**
 * 一、构造器引用
 * 
 * 和方法引用类似，函数式接口的抽象方法的形参列表和构造器的形参列表一致。
 * 
 * 抽象方法的返回值类型即为构造器所属的类的类型
 * 
 * 二、数组引用
 * 
 * 大家可以把数组看做是一个特殊的类，则写法与构造器引用一致。
 */
public class ConstructorRefTest {
    // 构造器引用
    // Supplier 中的 T get()
    // Employee 的空参构造器：Employee()
    @Test
    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());

        // ************************
        // Employee().....
        // Employee{id=0,name='null',age=0,salary=0.0}
        // ************************
        // Employee().....
        // Employee{id=0,name='null',age=0,salary=0.0}
    }

    // 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);

        // Employee(int id).....
        // Employee{id=1001,name='null',age=0,salary=0.0}
        // *****************
        // Employee(int id).....
        // Employee{id=1002,name='null',age=0,salary=0.0}
    }

    // 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, "Tom"));

        // Employee{id=1001,name='Tom',age=0,salary=0.0}
        // *****************
        // Employee{id=1002,name='Tom',age=0,salary=0.0}
    }

    // 数组引用
    // 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 = func2.apply(10);
        System.out.println(Arrays.toString(arr2));

        // [null, null, null, null, null]
        // *********************
        // [null, null, null, null, null, null, null, null, null, null]
    }
}