java8新特性总结——lambda表达式之方法引用与构造器引用

我们先来看一下Java8 内置的四大核心函数式接口结构

我们知道lambda表达式需要函数式接口的支持，即只有一个抽象方法的接口的支持。使用Lambda表达式语法即可优雅的完成功能。现在介绍Lambda表达式的另外的表现形式。还是先贴一段代码强化一下理解。

package com.atguigu.test;

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

import org.junit.Test;

import com.atguigu.java8.Employee;

public class TestRef {
	//对象的引用 :: 实例方法名
	@Test
	public void test1() {
		//在没有lambda表达式之前，如果我们想使用某个接口的一个方法，
		//例如Consumer<T>消费型接口的accept(T)方法，通常做法如下
		//①创建Consumer接口的匿名对象，
		//或者写个类实现这个接口的方法，然后用该类的对象调用accept
		Consumer<String> con1=new Consumer<String>() {
			@Override
			public void accept(String t) {
				System.out.println(t);
			}
		};
		con1.accept("我爱学习java");
		System.out.println("----------------------");
		//现在有了lambda表达式，可以进行优雅的简化
		Consumer<String> con2=(str) -> System.out.println(str);
		con2.accept("我也爱学习java");
		//现在要说的是lambda表达式的另一种形式，不同于上面的使用箭头操作符的形式
		//这种形式同样能达到相同效果
		//注意Consumer接口的accept方法接受一个参数没有返回值
		//同样的System.out也就是PrintStream的println此刻用的也是一个参数无返回值的方法（虽然方法重载）
		Consumer<String> con3=System.out::println;
		System.out.println("----------------------");
		con3.accept("怎么能少的了我呢");
	}
	
	@Test
	public void test2() {
		Employee emp=new Employee(101,"张三",20,9999);
		Supplier<String> sup1=new Supplier<String>() {
			@Override
			public String get() {
				return emp.getName();
			}
		};
		System.out.println(sup1.get());
		Supplier<String> sup2=()->emp.getName();
		System.out.println(sup2.get());
		Supplier<Integer> sup3=emp::getAge;
		System.out.println(sup3.get());
	}
	
	
	//类名 :: 静态方法名
	@Test
	public void test3() {
		Comparator<Integer> com=(x,y)->Integer.compare(x, y);
		System.out.println(com.compare(20, 30));
		System.out.println("-------------");
		Comparator<Integer> com2=Integer::compare;
		System.out.println(com2.compare(20, 30));
	}
	
	
	//类名 :: 实例方法名
	@Test
	public void test4() {
		Function<Employee, String> f1=Employee::getName;//传一个T(Employee)返回一个R(String)
		System.out.println(f1.apply(new Employee()));
		Function<Employee, Integer> f2=Employee::getAge;//传一个T(Employee)返回一个R(Integer)
		System.out.println(f2.apply(new Employee()));
	}
	
	//构造器引用    类名 :: new
	@Test
	public void test5() {
		Function<String, Employee> f1=Employee::new;
		//传入一个String 返回一个Employee对象，此时需要有构造器public Employee(String name) {}
		System.out.println(f1.apply("王五"));
		
	}
	//数组引用    类型[] :: new
	@Test
	public void test6() {
		Function<Integer, String[]> f=String[]::new;
		System.out.println(f.apply(10).length);
	}
}

具体规则总结如下：

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

如下图

使用构造器和方法引用大体就是这样，需要注意的就是使用时参数列表以及返回值需一致