方法引用和构造器引用

方法引用和构造器引用

大纲

1. 基本介绍

具体实例

基本介绍

使用情景：
当要传递给lambda体的操作，已经有实现的方法时，就可以使用方法的引用

方法引用，本质上就是lambda表达式，而lambda表达式作为函数式接口，方法引用，也是函数式接口的实例

使用格式：
类（或对象）：：方法名

方法引用的三种情况

对象：：非静态方法
类：：静态方法
类：：非静态方法
要求接口中的抽象方法的形参列表和返回值类型与方法引用的形参列表和返回值类型相同

对象::非静态方法

package lambda;

import org.junit.Test;

import java.io.PrintStream;
import java.util.function.Consumer;

public class cite {
    /**
     * 方法引用的使用格式：类（或对象）：：方法名
     * 首先Consume是函数式接口
     * 其中的方法为 void accept(T t)
     * 而对于PrintStream中的 void println(T t)
     * 两个方法的实现可以一样，所以我直接引用PrintStream的对象的println方法
     *
     */
    @Test
    public void test(){
        // 对象 ：： 非静态方法
        PrintStream ps = System.out;
        Consumer<String> con1 = ps::println;
        con1.accept("成功");
    }
}

类::静态方法

public class cite2 {
    @Test
    public void test(){
        // lambda 表达式
        Comparator<Integer> com1 = (t1,t2)->Integer.compare(t1,t2);
        // 这个传入lambda左边的参数，右边的方法体里面在调用的是其它的方法
        System.out.println(com1.compare(12,21));
        //
        // 方法引用(类::静态方法)
        Comparator<Integer> com2 = Integer::compare;
        // 因为这里我们要实现的比较操作和另外一个一样（Integer）
        System.out.println(com2.compare(12,3));
    }
    public void test1(){
        // 另一个 类::静态方法 的例子
        /**
         * Function 中的 R apply(T t)
         * Math 中的 Long round(Double d)
         * 那么对于Function的accept方法，就可以引用Math类的静态round方法
         */
        // lambda表达式
        Function<Double,Long> func1 = d -> Math.round(d);
        // 方法引用 类::静态方法
        Function<Double,Long> func2 = Math::round;
    }
}

类::非静态方法

类::非静态方法
不是非常的匹配(形参列表)

• Comparator 中的int compare(T t1,T t2);
• String 中的int t1.compareTo(t2)
• 对于Comparator 的compare方法，有两个参数，但是String的compareTo方法只有一个参数
• 可以把String 的 compareTo 的调用者t1，当作compare中的t1

package lambda;

import java.util.Comparator;
import java.util.function.BiPredicate;

/**
 * 类::非静态方法
 * 不是特别匹配
 * Comparator 中的int compare(T t1,T t2);
 * String 中的int t1.compareTo(t2)
 * 对于Comparator 的compare方法，有两个参数，但是String的compareTo方法只有一个参数
 * 可以把String 的 compareTo 的调用者t1，当作compare中的t1
 */
public class cite3 {
    public void  test(){
        // lambda 表达式
        Comparator<String> com1= (s1,s2)-> s1.compareTo(s2);
        com1.compare("abc","abd");
        // 方法引用
        Comparator<String> com2 = String::compareTo;
        com2.compare("sea","asd");
    }
    /**
     * 第二个例子
     * BiPredicate 中的 boolean test(T t1,T t2);
     * String 中的 boolean t1.equals(t2)
     */
    public void test1(){
        // lambda 表达式
        BiPredicate<String,String> pre1 = (s1,s2) -> s1.equals(s2);
        // 方法引用 类::非静态方法
        BiPredicate<String,String> pre2 = String::equals;
    }
}

构造器引用

注意前面泛型的类型，就是后面形参传入的顺序

package lambda;

import java.util.function.Supplier;

public class constructorCite {
    // 构造器引用
    // Supplier 中的 T get()
    // Employee 的无参构造器:Employee()
    Supplier<Employee> sup = new Supplier<Employee>() {
        @Override
        public Employee get() {
            return null;
        }
    };
    // lambda 表达式
    Supplier<Employee> sup1 = () -> new Employee();
    // 构造器引用
    Supplier<Employee> sup2 = Employee::new;
}

package lambda;

import java.util.function.Function;
import java.util.function.Supplier;

public class constructorCite {
    // Function 中的 R apply(T t)
    // 通过这个传入一个参数，返回其的构造的对象
    // lambda 表达式
    Function<Integer,Employee> func1 = id -> new Employee(id);
    // 构造器引用
    Function<Integer,Employee> func2 = Employee::new;
}

public class constructorCite {
    // BiFunction 中的 R apply(T t,U u);
    // 通过传入两个参数构造返回一个R的对象
    public void test() {
        // lambda 表达式
        BiFunction<String, Integer, Employee> func1 = (name, id) -> new Employee(name, id);
        BiFunction<String, Integer, Employee> func2 = Employee::new;
        func2.apply("wantian",1);
    }
}

数组引用

可以把数组看成一个特殊的类，创建数组，就是利用构造器，所以数组引用和构造器引用类似

public class arrayCite {
    /**
     * 数组引用
     * 可以把数组看成一个特殊的类
     * 数组引用类似于构造器引用
     */
    public void test(){
        // lambda 表达式
        Function<Integer,String[]> func1 = length -> new String[length];
        String [] arr1 = func1.apply(5);

        // 数组引用
        Function<Integer,String[]> func2 = String[] ::new;
    }
}