java_方法引用和构造器引用

一、方法引用

1.1、方法引用的理解

• 方法引用，可以看做是基于lambda表达式的进一步刻画
• 当需要提供一个函数式接口的实例时，可以使用lambda表达式提供此实例
• 当满足一定条件时，还可以使用方法引用或构造器引用替换lambda表达式

1.2、格式

总体理解：类（对象）::方法名

• 对象 :: 实例方法名
• 类 :: 静态方法名
• 类 :: 实例方法名

1.3、举例

前提：Lambda体只有一句语句，并且是通过调用一个对象/类现有的方法来完成的

• 对象 :: 实例方法名

	@Test
	public void test1() {
		// 1.匿名实现类
		Consumer<String> con1 = new Consumer<String>(){
			@override
			public void accept(String s){
				System.out.pringln(s);
			}
		}
		// 2.lambda表达式
		Consumer<String> con1 = s -> System.out.println(s);
		// 3.方法引用
		Consumer<String> con2 = System.out::println;
	}

1、accept()方法的形参、返回值和println()方法的一样，所以可用方法引用代替lambda表达式
2、函数式接口中的抽象方法a在被重写时使用了某一个对象的实例方法b。如果方法a的形参列表、返回值类型与实例方法b的形参列表、返回值类型都相同(满足多态场景也可以)，则我们可以使用方法b实现对方法a的重写、替换。

• 类 :: 静态方法名

	@Test
	public void test3() {
		// 1.匿名实现类
		Comparator<Integer> com1 = new Comparator<Integer>(){
			@override
			public int compare(Integer o1,Integer o2){
				return Integer.compare(o1,o2);
			}
		}
		// 2.lambda表达式
		Comparator<Integer> com1 = (t1,t2) -> Integer.compare(t1,t2);
  		// 3.方法引用
		Comparator<Integer> com2 = Integer::compare;
	}

函数式接口中的抽象方法a在被重写时使用了某一个类的静态方法b。如果方法a的形参列表、返回值类型与方法b的形参列表、返回值类型都相同(满足多态场景也可以)，则可以使用方法b实现对方法a的重写、替换。

• 类 :: 实例方法名

	@Test
	public void test5() {
		// 1.匿名实现类
		Comparator<String> com1 = new Comparator<String>(){
			@override
			public int compare(String o1,String o2){
				retrun o1.compareTo(o2);
			}
		}
		// 2.lambda表达式
		Comparator<String> com1 = (s1,s2) -> s1.compareTo(s2);
		// 3. 方法引用
		Comparator<String> com2 = String :: compareTo;
	}

函数式接口中的抽象方法a在被重写时使用了某一个对象的方法b。如果方法a的返回值类型与方法b的返回值类型相同(满足多态场景也可以)，同时方法a的形参列表中有n个参数，方法b的形参列表有n-1个参数，且方法a的第1个参数作为方法b的调用者，且方法a的后n-1参数与方法b的n-1参数匹配（类型相同或满足多态场景也可以）

二、构造器引用

2.1、格式

类名::new

• 调用类名对应的类中的某一个确定的构造器
• 具体调用的是哪一个构造器？取决于函数式接口的抽象方法的形参列表

2.2、例子

	@Test
    public void test1(){
		// 1.匿名实现类
        Supplier<Employee> sup = new Supplier<Employee>() {
            @Override
            public Employee get() {
                return new Employee();
            }
        };
		// 2.lambda表达式
        Supplier<Employee>  sup1 = () -> new Employee();
		// 3.构造器引用， 调用的是Employee类中的空参构造器
        Supplier<Employee>  sup2 = Employee :: new;
    }

	@Test
    public void test2(){
    	// 1.lambda表达式
        Function<Integer,Employee> func1 = id -> new Employee(id);
 		// 2.构造器引用，调用的是Employee类中的Employee(int id)这个构造器
        Function<Integer,Employee> func2 = Employee :: new;
    }

2.3、数组引用

• 格式：数组类型名::new
• 例子

@Test
public void test(){
	// 1.匿名实现类
	Function<Integer,String[]> func1 = new Function<Integer,String[]>{
		@override
		public String[] apply(Integer length){
			return new String[length];
		}
	}
	// 2.lambda表达式
    Function<Integer,String[]> func1 = length -> new String[length];
    String[] arr1 = func1.apply(5);
    // 3.数组引用
    Function<Integer,String[]> func2 = String[] :: new;
    String[] arr2 = func2.apply(10);
}