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

浅浅的花香味﹌ 2022-08-09 06:55 212阅读 0赞

方法引用的唯一用途是支持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
    {
    	
    }