JDK1.8新特性之方法引用(Method References)

方法引用的唯一用途是支持Lambda表达式的简写，不用Lambda表达式，就用不着方法引用

方法引用分为4类，常用的是前三种。方法引用也受到访问控制权限的限制，可以通过在引用位置是否能够调用被引用方法来判断。具体分类信息如下：

• 引用静态方法 
  ContainingClass::staticMethodName 
  例子: String::valueOf，对应的Lambda：(s) -> String.valueOf(s) 
  比较容易理解，和静态方法调用相比，只是把.换为::

• 引用特定对象的实例方法 
  containingObject::instanceMethodName 
  例子: x::toString，对应的Lambda：() -> this.toString() 
  与引用静态方法相比，都换为实例的而已

• 引用构造函数 
  ClassName::new 
  例子: String::new，对应的Lambda：() -> new String() 
  构造函数本质上是静态方法，只是方法名字比较特殊。

• 引用特定类型的任意对象的实例方法 
  ContainingType::methodName 
  例子: String::toString，对应的Lambda：(s) -> s.toString() 
  太难以理解了。难以理解的东西，也难以维护。建议还是不要用该种方法引用。 
  实例方法要通过对象来调用，方法引用对应Lambda，Lambda的第一个参数会成为调用实例方法的对象。

以下是示例代码：

package com.example;

import java.util.Arrays;
import java.util.Collections;
import java.util.List;
import java.util.function.Supplier;

public class MethodReferenceTest 
{
	//简单的例子
	static void example1()
	{
		MyThread mt = new MyThread();
		//Lambda表达式写法
		new Thread( () -> {System.out.println("Lambda 执行线程 ... ");}).start();
		
		//方法引用写法
		new Thread(mt::run).start();
		
		//定义变量 , 下面三种方式效果一样
		//Lambda
		Runnable r1 = () -> {};
		
		//引用实例方法
		Runnable r2 = mt::run;
		
		//引用静态方法
		Runnable r3 = MyThread::run2;
	}
	
	//排序的例子
	static void example2()
	{
		List<String> list = Arrays.asList("dad", "bex", "zws", "hxe");
		
		//Lambda表达式写法
		Collections.sort(list, (a, b) -> {return a.compareTo(b);});
		
		//方法引用写法
		Collections.sort(list, new MyUtil()::compareTo);
		System.out.println(list);
	}
	
	//引用构造函数  1
	static void example3()
	{
		//Lambda表达式写法
		UserFactory uf1 = new UserFactory(() -> {return new User();});
		
		//方法引用写法
		UserFactory uf2 = new UserFactory(User::new);
	}
	
	//引用构造函数  2
	static void example4()
	{
		//Lambda表达式写法
		Supplier<String> s1 = () -> {return "222";};
		System.out.println(s1.get());
		
		//方法引用写法
		Supplier<MyThread> s2 = MyThread::new;
		System.out.println(s2.get());
	}
	
	public static void main(String[] args)
	{
		example1();
		example2();
		example3();
		example4();
	}
}

class MyThread
{
	public void run()
	{
		System.out.println("MyThread 执行线程 ... ");
	}
	
	public static void run2()
	{
		System.out.println("MyThread static 执行线程 ... ");
	}
}

class MyUtil
{
	public int compareTo(String a, String b)
	{
		return a.compareTo(b);
	}
}

class UserFactory
{
	private Supplier<User> supplier;
	public UserFactory(Supplier<User> supplier)
	{
		this.supplier = supplier;
	}
	public void show()
	{
		System.out.println(supplier.get());
	}
}
class User
{
	
}