Java8 新特性之方法引用(深入理解双冒号的使用)

本博客部分参考：

https://blog.csdn.net/u012784162/article/details/106538516

https://blog.csdn.net/zhoufanyang_china/article/details/87798829

我们在遍历一个list列表中常常用到的方法是：

for(String s:list){
    System.out.println(s);
}

他进一步使用Lambda表达式优化得到：

list.forEach(s->System.out.println(s))

再进一步优化：

list.forEach(System.out::println);//注意是方法的最后一个本来应该写参数的前加双::
//例如非静态方法调用中
StringBuilder stringBuilder = new StringBuilder();
//化简前
IntStream.range(1, 101).forEach(item -> stringBuilder.append(item));
//化简后
IntStream.range(1, 101).forEach(stringBuilder::append);

这里使用的双冒号::的方法就是方法引用的一种形式。

方法引用：

我们用Lambda表达式来实现匿名方法。但有些情况下，我们用Lambda表达式仅仅是调用一些已经存在的方法，除了调用动作外，没有其他任何多余的动作，在这种情况下，我们倾向于通过方法名来调用它，而Lambda表达式可以帮助我们实现这一要求，它使得Lambda在调用那些已经拥有方法名的方法的代码更简洁、更容易理解。方法引用可以理解为Lambda表达式的另外一种表现形式。

总结方法引用大体分为：

1. 静态方法引用（static method）语法：classname::methodname 例如：Person::getAge
2. 对象的实例方法引用语法：instancename::methodname 例如：System.out::println
3. 对象的超类方法引用语法： super::methodname
4. 类构造器引用语法： classname::new 例如：ArrayList::new
5. 数组构造器引用语法： typename[]::new 例如： String[]:new

方法引用的总体使用方法就是：方法隶属::方法名称

静态方法引用

public class Test {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("1", "b", "cc");
        list.forEach(Test::print);
    }
    public static void print(String content){
        System.out.println(content);
    }
}

在使用接口定义的时候例如：

public class Test {
    public static void main(String[] args) {
        Test01 t = Test::print;
        //可以写成Test01 t = Test::print1;
        t.print(1L);
    }
    public static void print(Long content){
    //可以写成public static void print1(Long content)不可以修改成与接口不同的参数类型
        System.out.println(content);
    }
}
interface Test01{
    void print(Long content);

我们至少要保证函数的参数类型不能改变，我们可以修改函数名称，不可以修改成与接口不同的参数类型

对象的实例方法引用

public class Test {
    public static void main(String[] args) {
        List<String> list = Arrays.asList("1", "b", "cc");
        list.forEach(new Test()::print);
    }
    public void print(String content){
        System.out.println(content);
    }
}

对象的超类方法引用

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);
	}
}

类构造器引用语法

默认构造函数：

public class Example {

	@Test
	public void test() {
		InterfaceExample com =  Example::new;
		Example bean = com.create();	
		System.out.println(bean);
	}
}

interface InterfaceExample{
	Example create();
}

如果是带参数的构造器，示例如下：

public class Example {
	
	private String name;
	
	Example(String name){
		this.name = name;
	}
	
	public static void main(String[] args) {
		InterfaceExample com =  Example::new;
		Example bean = com.create("hello world");
		System.out.println(bean.name);
	}
}
interface InterfaceExample{
	Example create(String name);
}

这里需要特别注意的是：Example 类并没有implements InterfaceExample接口哦！！！

数组构造器语法使用例子：

import java.util.function.Function;

/**
 * @author zhoufy
 * @date 2019年2月20日 下午2:19:13
 */
public class Example {
	public static void main(String[] args) {
		Function <Integer, Example[]> function = Example[]::new;
		Example[] array = function.apply(4);	//这里的4是数组的大小
		
		for(Example e:array){
			System.out.println(e);	//如果输出的话，你会发现会输出4个空对象(null)
		}
	}
}

• 自带的java.util.function.Function类实现的，如果想要自定义接口

public class Example {
	
	public static void main(String[] args) {
		Interface <Integer, Example[]> function = Example[]::new;
		Example[] array = function.apply(4);	//这里的4是数组的大小
		
		for(Example e:array){
			System.out.println(e);
		}
	}
}

@FunctionalInterface
interface Interface<A, T>{
	T apply(A a); 
}

双冒号的使用条件

使用双冒号有两个条件：

条件1

条件1为必要条件，必须要满足这个条件才能使用双冒号。
Lambda表达式内部只有一条表达式（第一种Lambda表达式），并且这个表达式只是调用已经存在的方法，不做其他的操作。

条件2

由于双冒号是为了省略item ->这一部分，所以条件2是需要满足不需要写参数item也知道如何使用item的情况。
有两种情况可以满足这个要求，这就是我将双冒号的使用分为2类的依据。

情况	举例
Lambda表达式的参数与调用函数的参数完全一致	list.forEach(item -> System.out.println(item))
调用的函数是参数item对象的方法且没有参数	list.stream().map(item -> item.getId())