Java- 方法引用、构造器引用、数组引用

方法引用

方法引用本质上就是Lambda表达式，而Lambda表达式本质上是函数接口的实例化，那么方法引用本质上也是函数接口的实例化。
格式： 类（对象） ::  方法名  
不需要参数列表

对象 :: 非静态方法

类  :: 静态方法

 方法引用使用要求： 函数接口中抽象方法的形参列表和返回值类型，与方法引用的方法 的形参列表和返回值类型都相同

类 :: 非静态方法

Comparable  int compare（o1,o2)

String int o1.compareTo(o2)

默认 o1 作为对象调用的。

 拓展： 当函数接口的抽象方法，有两个不同参数类型， 并且方法引用的方法，参数列表有省略情况 ：

                1. 只能省略第一个参数；

                2.  ::  前导的类型 也必须是第一参数类型（省略的参数会通过::前导类型默认创建

 Lambda 不关心方法名，因为FI只有一个接口，并且根据参数来匹配

---

---

构造器引用： 和方法引用类似，函数式接口的抽象方法形参列表和构造器形参列表一致；

                       抽象方法的返回值类型  即为  构造器所属类的类型

 数组引用： 可以把数组看作是一个特殊的类，那么和构造器引用一样了

---

---

---

举个栗子：

情况一： 对象  ::  实例方法 

Consumer   void  accept( T t)

PrintStream  void println(T t)

当传递给Lambda体（接口<泛型> 变量名 = ） 的操作，已给有实现方法了，可以使用方法引用

 @Test
    public void test1() {

        Consumer<String> con = new Consumer<String>() {
            @Override
            public void accept(String s) {
                System.out.println(s);
            }
        };
        con.accept("天下古今之庸人，皆以一“惰”字致败");
        System.out.println("------------------------------");

        Consumer<String> con2 = (str) -> {
            System.out.println(str);
        };
        con2.accept("勤字功夫，第一贵早起，第二贵有恒;");
//--------------------------------------------------------------
        PrintStream out = System.out;
        Consumer<String> con4 = out::println;  //对象方法
        con4.accept("盖士人读书，第一要有志，第二要有识，第三要有恒。");

        Consumer<String> con3 = System.out::println;
        Consumer<String> con5 = Tempclass.out::print;
        con3.accept("家俭则兴，人勤则健，能勤能俭，永不贫贱");
    }

 

 @Test
    public void test2() {

        //Supplies  T get()
        //Employee  String getName()
        Employee employee = new Employee(555, "张飞", 23, 8000);

        Supplier<String> sup1 = () -> employee.getName();

        Supplier<String> sup = employee::getName;  //实现的是getName()方法体
        System.out.println(sup.get());
    }

---

---

 

情况二： 类 :: 静态方法 

 @Test
    public void test3() {
        //Comparator  int  compareTo( Object o1 ,o2)
        //Integer  int compare(int i1, i2)
        Comparator<Integer> com = new Comparator<Integer>() {
            @Override
            public int compare(Integer o1, Integer o2) {
                return Integer.compare(o1, o2);
            }
        };
        com.compare(12, 45);

        Comparator<Integer> com2 = (o1, o2) -> Integer.compare(o1, o2);
        com2.compare(23, 45);

        Comparator<Integer> com3 = Integer::compare;
        com3.compare(23, 45);
    }

@Test
    public void test4() {
        //Function<T,R>   R apply(T t)
        //Math  Long  round(Double d)
        Function<Double, Long> fun = new Function<Double, Long>() {
            @Override
            public Long apply(Double d) {
                return Math.round(d);
            }
        };

        Function<Double, Long> fun2 = d -> Math.round(d);
        System.out.println(fun2.apply(3.2));

        Function<Double, Long> fun3 = Math::round;

    }

 

---

---

情况三： 类  ::  实例方法 

  //Comparable   int compare(o1,o2)
        //String    int  o1.compareTo(o2)
        Comparator<String> com = (o1, o2) -> {
            return o1.compareTo(o2);
        };
        Comparator<String> com2 = String::compareTo;

---

---

 

 构造器引用：

 

  //无参构造器引用
    @Test
    public void test7() {
        // Supplier  T get();
        //Employee   Emoploye();

        Supplier<Employee> sup = new Supplier<Employee>() {
            @Override
            public Employee get() {
                return new Employee();
            }
        };
        System.out.println(sup.get());

//        ---------------------------------------------
        Supplier<Employee> sup2 = ()->{
            return new Employee();
        };

        Supplier<Employee> sup3 = Employee::new;
    }

    //一个参数构造器
    @Test
    public  void test8(){

       // Function<T,R>  R aplly(T t)
        //Employee     Employee(int id)
        Function<Integer,Employee> fun = new Function<Integer, Employee>() {
            @Override
            public Employee apply(Integer integer) {
                return new Employee(integer);
            }
        };

        Function<Integer, Employee> fun2 = id -> new Employee(id);

        Function<Integer,Employee>fun3 = Employee::new;
    }

两个参数构造器
 @Test
    public void test9(){
       //BiFunction<T,U,R>  R apply(T t, U r);
        //Employee       Employee(int id,String name)
        BiFunction<Integer,String,Employee> bif = 
                                new BiFunction<Integer, String, Employee>() {
            @Override
            public Employee apply(Integer id, String s) {
                return new Employee(id, s);
            }
        };

        BiFunction<Integer, String, Employee> bif2 =
                                 (id, str) -> new Employee(id, str);

        BiFunction<Integer,String,Employee> bif3 = Employee::new;

    }

---

---

数组引用： 

@Test
    public  void test10(){
        //Funtion  R apply(T t)
        Function<Integer, String[]> fun = Length -> new String[Length];

        Function<Integer,String[]> fun2 = String[]::new;

    }