【方法引用】构造器，数组引用，四大函数式接口。3种方法引用：对象::实例方法。类::静态方法。类::实例方法。

1. 四大核心函数式接口

* JAVA8 内置的四大核心函数式接口
*
* Consumer<T> :消费型接口
*          void accept(T t);

* Supplier<T> :供给型接口
*          T get();

* Function<T, R> :函数型接口
*          R apply(T t);

* Predicate<T>   :断言型接口
*          boolean test(T t);

2. 方法引用

写 lambda 时，有方法已经实现了，

方法引用:若Lambda 体中的内容有方法已经实现了，我们可以使用"方法引用"

• 可以理解为方法引用是Lambda表达式的另外一种表现形种

主要有三种语法格式:

对象::实例方法名

类::静态方法名

类::实例方法名

• 注意点

//返回值 和 参数 要保持一致。
//1. Lambda 体中调用方法的参数列表与返回值类型,要与函数式接口中抽象方法的函数列表和返回值类型保持一致!
//2. 若Lambda参数列表中的第一参数是实例方法的调用者，而第二个参数是实例方法的参数时，可以使用ClassName :: method

对象 + 实例方法名

		//传统的写法
        Consumer<String> con1 = (x) -> System.out.println(x);
        con1.accept("1111");

		//创建一个对象
        PrintStream ps = System.out;
		//传统 使用对象 调用方法
        Consumer<String> con2 = (x) -> ps.println(x);

        //对象::实例方法名。lambda 方法体中，如果已经有方法 完成了这个功能的时候，就可以用。
        Consumer<String> con3 = ps::println;
		//连在一起 写
        Consumer<String> con4 = System.out::println;
        //注意消费型函数 和 这个方法参数返回值一样：    void accept(T t); 和 public void println(String x) {


		//提供型函数
        Supplier<String> sup1 = () -> {
            return "1";
        };
        Supplier<String> sup2 = () -> "1";

        System.out.println(sup2.get());

        Employee e = new Employee();
        //Supplier T get(); 和 getAge一样。使用对象::
        Supplier<Integer> sup3 = e::getAge;

类+静态方法

        //类::静态方法名
        Comparator<Integer> com1 = (x, y) -> x - y;
        //Comparator int compare(T o1, T o2);
        //Integer类的： public static int compare(int x, int y) {

		//比较器，使用 Integer的方法
        Comparator<Integer> com2 = (x, y) -> Integer.compare(x, y);
        System.out.println(com2.compare(1, 2));
		
		//直接使用类::
        Comparator<Integer> com3 = Integer::compare;

类+实例方法

        //类::实例方法名
        //BiPredicate  boolean test(T t, U u);
        //String  public boolean equals(Object anObject) {
        BiPredicate<String, String> bp1 = (x, y) -> x.equals(y);

        //第一个参数是 调用者， 第二个参数，作为调用者的参数。才可以用。
        BiPredicate<String, String> bp2 = String::equals;

3. 构造器引用

格式:
ClassName: :new

注意:需要调用的构造器的参数列表要与函数式接口中抽象方法的参数列表保持一致!|

        //Supplier T get(); 方法要一致，所以 是 无参的 public Employee()
        Supplier<Employee> s1 = () -> new Employee();
		
		//类::new创建对象
        Supplier<Employee> s2 = Employee::new;
        System.out.println(s2.get());

		//使用 函数，第一个参数作为 第二个参数的对象
        Function<Integer, Employee> fun1 = (age) -> new Employee(age);

        //R apply(T t); 自动寻找：public Employee(Integer age)
        Function<Integer, Employee> fun2 = Employee::new;
        System.out.println(fun2.apply(1));

        //三个参数。对应：public Employee(String name, Integer age)
        BiFunction<String, Integer, Employee> fun3 = Employee::new;

4. 数组引用

Type[]::new

        Function<Integer, String[]> fun = (x) -> new String[x];
        String[] apply = fun.apply(10);

        Function<Integer, String[]> fun2 = String[]::new;
        //10
        System.out.println(fun2.apply(10).length);