java8新特性-方法引用和构造器引用

概述

java8新特性中给我们提供了方法引用和构造器的引用，可以让我们在编程的时候更见快捷方便，够装逼。前面的博客中已经对java8中的新特性，lambda表达式，函数式编程等进行了学习，如果看懂了前面的这里就很简单了。有疑问的小伙伴可以看看前面的文章进行学习，这里进行java8中方法的引用和构造器的引用进行学习。

方法引用和构造器引用

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

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

2. 类名 :: 静态方法名

3. 类名 :: 实例方法名

import org.junit.Test;
import java.io.PrintStream;
import java.util.*;
import java.util.function.*;

/*
 * 一、方法引用：若 Lambda 体中的功能，已经有方法提供了实现，可以使用方法引用
 * 			  （可以将方法引用理解为 Lambda 表达式的另外一种表现形式）
 *
 * 1. 对象的引用 :: 实例方法名
 *
 * 2. 类名 :: 静态方法名
 *
 * 3. 类名 :: 实例方法名
 *
 * 注意：
 * 	 ①方法引用所引用的方法的参数列表与返回值类型，需要与函数式接口中抽象方法的参数列表和返回值类型保持一致！
 * 	 ②若Lambda 的参数列表的第一个参数，是实例方法的调用者，第二个参数(或无参)是实例方法的参数时，格式： ClassName::MethodName
 *
 * 二、构造器引用 :构造器的参数列表，需要与函数式接口中参数列表保持一致！
 *
 * 1. 类名 :: new
 *
 * 三、数组引用
 *
 * 	类型[] :: new;
 */
public class MethodRefTrain {

    //对象的引用 :: 实例方法名
    @Test
    public void test1(){
        List<String> list = Arrays.asList("java","spark","hadoop","scala");
        list.forEach( x -> System.out.println(x) );

        PrintStream out = System.out;
        list.forEach( x -> out.println(x) );

        list.forEach(System.out::println);
    }

    //对象的引用 :: 实例方法名
    @Test
    public void test2(){
        User user = new User(1,"飞飞",26,17000.00);
        Supplier<String> sp = () -> user.getName();
        System.out.println(sp.get());

        Supplier<String> sp1 = user::getName;
        System.out.println(sp1.get());
    }

    //类名 :: 静态方法名

    /**
     * 静态方法:compare
     * public static int compare(int x, int y) {
     *         return (x < y) ? -1 : ((x == y) ? 0 : 1);
     *     }
     */
    @Test
    public void test3(){
        Comparator<Integer> cm = (x,y) -> Integer.compare(x,y);

        Comparator<Integer> cm1 = Integer::compare;
    }

    //类名 :: 实例方法名
    @Test
    public void test4(){
        BiPredicate<String,String> bp = (x,y) -> x.equals(y);
        System.out.println(bp.test("aaa", "bbb"));

        BiPredicate<String,String> biPredicate = String::equals;
    }

    //类名 :: new
    @Test
    public void test5(){
        //和user类中的构造器参数保持一致
        Function<Integer,User> function = User::new;
        User user1 = function.apply(1001);
        System.out.println(user1);

        Function<Integer,User> fu = (x) -> new User(x);
        User user = fu.apply(1);
        System.out.println(user);

        BiFunction<Integer,String,User> bf = User::new;
        User jack = bf.apply(001, "jack");
        System.out.println(jack);

        BiFunction<Integer,String,User> bf1 = User::new;
        User tom = bf.apply(002, "tom");
        System.out.println(tom);

    }

    //数组引用
    @Test
    public void test6(){
        Function<Integer,String []> fc = x-> new String[x];

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

}

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