JDK8新特性5——Lambda表达式方法引用

        双冒号（::）运算符在Java 8中被用作方法引用（method reference），方法引用是与lambda表达式相关的一个重要特性。它提供了一种不执行方法的方法。为此，方法引用需要由兼容的函数接口组成的目标类型上下文。

        方法引用可以理解为是让指定的方法去重写接口的抽象方法，到时候调用接口的抽象方法就是调用传递的这个方法

例如：我们可以将方法getSum传递给sunIntArr，当consumer执行accept的时候，就相当于是执行了我们传递的方法getSum

package com.bjc.jdk8.objRef;

import java.util.function.Consumer;

public class Demo1 {
    public static void main(String[] args) {
        int[] arr = {1,2,4,5,6,2,3};
        sumIntArr(Demo1::getSum,arr);
    }

    // 定义一个方法用于对数组求和
    public static void getSum(int[] arr){
        int sum = 0;
        for (int i : arr) {
            sum += i;
        }
        System.out.println(sum);
    }

    public static void sumIntArr(Consumer<int[]> consumer,int[] arr){
        consumer.accept(arr);
    }
}

通过上面的例子，我们可以知道方法引用用到了双冒号::写法，这种被称之为“方法引用”，是一种新的语法

1. 方法引用的格式

符号表示：双冒号::

符号说明：双冒号方法引用运算符，而它所在的表达式被称为方法引用

应用场景：如果Lambda所要实现的方案，已经有其他方法存在相同的方案，那么则可以使用方法引用

2. 常见的引用方式

方法引用在JDK8中相当灵活，有以下几种形式：

2.1 对象名::引用成员方法名（instanceName::methodName）

这是最常见的一种用法，如果一个类中已经存在了一个成员方法，则可以通过对象名引用成员方法。

需要注意的是：

1）被引用的方法，参数要和抽象接口中抽象方法的参数一样

2）当接口抽象方法有返回值时，被引用的方法也必须有返回值

例如：

@Test
public void test01(){
	Supplier<Long> supplier = () -> {
	    return new Date().getTime();
	};
	Long aLong = supplier.get();
	System.out.println(aLong);
}

Supplier函数式接口中有一个get方法，没有参数，有一个返回值，Supplier的泛型类型就是get的返回值，Lambda表达式就相当于是对get方法的一个重写 

可以改成如下引用：

@Test
public void test01(){
	Supplier<Long> supplier = new Date()::getTime;
	Long aLong = supplier.get();
	System.out.println(aLong);
}

7.2.2 类名::引用静态方法名（ClassName::staticMethodName）

例如：引用System类的静态方法currentTimeMillis

@Test
public void test02(){
	Supplier<Long> supplier = System::currentTimeMillis;
	Long aLong = supplier.get();
	System.out.println(aLong);
}

7.2.3 类名::引用方法名（ClassName::methodName）

java面向对象中，类名只能调用静态方法，类名引用实例方法是有前提的，实际上是拿第一个参数作为方法的调用者。

例如：

@Test
public void test03(){
	Function<String,Integer> func = String::length;
	Integer apply = func.apply("hello");
	System.out.println(apply);

	BiFunction<String,String,String[]> func2 = String::split;
	String[] apply2 = func2.apply("hello",",");
	System.out.println(apply2);
}

在第一个例子中，Function接收的参数有2个，第一个是调用者，第二个返回值，所以使用类名::引用方法名的时候，要求引用方法名不能带参数，且其返回值与Function接口的第二个泛型类型相同

在第二个例子中，BiFunction接收三个参数，第三个参数是返回值，其抽象方法apply接收三个参数，所以，使用类名::引用方法名的时候，要求引用方法名只能带一个参数，且参数类型与BiFunction接口的第二个泛型类型相同，且方法返回值与BiFunction接口的第三个泛型类型相同。

第二个例子就相当于是

 BiFunction<String,String,String[]> func3 = (str1,str2) -> {
     return str1.split(str2);
};
System.out.println(func3.apply("hellow",","));

7.2.4 类名::new引用构造器（ClassName::new）

由于构造器的名称与类名完全一样，所以构造器引用使用  类名称::new  的格式表示

@Test
public void test04(){
        Supplier<Person> supplier = Person::new;
	Person person = supplier.get();
	person.setName("张三");
	System.out.println(person);

	Function<String,Person> func = Person::new;
	Person person1 = func.apply("张三1");
	System.out.println(person1);
}

上面的两个例子，当调用无参的构造器的时候，使用supplier的get，有一个参数的构造器就使用Function接口的apply，如果两个参数了？可以使用BiFunction接口了。

7.2.5 引用数组构造器（TypeName[]::new）

数组也是Object的子类对象，所以同样具有构造器，只是语法稍有不同。

语法：类型[]::new

例如：

@Test
public void test05(){
	Function<Integer,int[]> func = int[]::new;
	int[] apply = func.apply(5);
	System.out.println(Arrays.toString(apply));
}

7.2.6 对象的超类方法引用（super::methodname）

public class Example extends BaseExample{

	@Test
	public void test() {
		List<String> list = Arrays.asList("aaaa", "bbbb", "cccc");
		
		//对象的超类方法语法： super::methodName 
		list.forEach(super::print);
	}
}

class BaseExample {
	public void print(String content){
		System.out.println(content);
	}
}

小结：方法引用是对特定情况下的Lambda表达式的一个简写，它使得Lambda表达式更加的精简，不过需要注意的是，方法引用只能引用已经存在的方法。