【Java】【Lambda】Lambda方法引用常见的几种用法

基本用法： 直接拿参数执行代码，推导出返回值

	public class Test {
	
	    public static void main(String[] args) {
	        AddressComparator comparator = (source, target) -> {
	            return source.hashCode() - target.hashCode();
	        };
	    }
	
	    public int compare(Object target) {
	        return hashCode() - target.hashCode();
	    }
	
	    public interface AddressComparator {
	        int compare(Test source, Object target);
	    }
	}

省略用法： 当执行代码只有一行时，可以省略代码块和return

	public class Test {
	
	    public static void main(String[] args) {
	        AddressComparator comparator = (source, target) -> source.hashCode() - target.hashCode();
	    }
	
	    public int compare(Object target) {
	        return hashCode() - target.hashCode();
	    }
	
	    public interface AddressComparator {
	        int compare(Test source, Object target);
	    }
	}
	

引用类的静态方法： 当类中含有参数列表，返回值类型和接口方法完全一致的静态方法时，可以引用这个类静态方法

	public class Test {
	
	    public static void main(String[] args) {
	        AddressComparator comparator = Test::compare;
	    }
	
	    public static int compare(Test source, Object target) {
	        return 0;
	    }
	
	    public interface AddressComparator {
	        int compare(Test source, Object target);
	    }
	}

引用特定对象的方法： 当对象中含有参数列表，返回值类型和接口方法完全一致的方法时，可以引用这个对象方法 当某个对象执行代码时，要引用父类或自己的方法，可以使用this或super指定作用域

	public class Test {
	
	    public static void main(String[] args) {
	        Test test = new Test();
	        AddressComparator comparator = test::compare;
	    }
	
	    public void run(){
	        AddressComparator comparator = this::compare;
	    }
	
	    public int compare(Test source, Object target) {
	        return source.hashCode() - target.hashCode();
	    }
	
	    public interface AddressComparator {
	        int compare(Test source, Object target);
	    }
	}
	

引用任意对象的方法： 这种模式下，会将接口方法的第一个参数作为执行对象，调用引用方法去执行后面的参数 显然，这种模式下，接口方法的第一个参数要和引用类类型一致，引用方法参数列表和接口方法后续参数列表一致

	public class Test {
	
	    public static void main(String[] args) {
	        //使用source.compareTo(target)作为接口方法返回值
	        AddressComparator comparator = Test::compare;
	    }
	
	    public int compare(Object target) {
	        return hashCode() - target.hashCode();
	    }
	
	    public interface AddressComparator {
	        int compare(Test source, Object target);
	    }
	}

引用构造方法： 当类中含有和接口方法参数列表，返回值类型完全一致的构造方法时，可以直接引用这个类的构造方法

	public class Test {
	
	    public static void main(String[] args) {
	        AddressComparator comparator = Test::new;
	    }
	
	    public Test() {
	    }
	
	    public Test(int arg) {
	    }
	
	    public Test(int[] args) {
	    }
	
	    public interface AddressComparator {
	        void compare(int arg);
	    }
	}
	

引用数组构造方法： 这种情形，要求接口方法必须接收int，返回数组 接口方法的实际实现方式，就是创建一个int长度的数组

	public class Test {
	
	    public static void main(String[] args) {
	        AddressComparator comparator = int[]::new;
	        int[] compare = comparator.length(10);
	        System.out.println(compare.length);
	    }
	
	    public interface AddressComparator {
	        R length(int arg);
	    }
	}

数组构造方法式lambda一个很重要的用途，就是用来创建泛型数组 由于泛型的实际类型是不确定的，不一定有public构造方法，因此一定是无法new出来的 而通过lambda，我们则可以用一种比较优雅的方式来间接new一个泛型数组

	public class Test {
	
	    private static final List list = new ArrayList();
	
	    static {
	        list.add("item");
	        list.add("item");
	        list.add("item");
	        list.add("item");
	    }
	
	    public static void main(String[] args) {
	        ListArrayConvertor convertor = String[]::new;
	        String[] array = convertor.listToArray(list);
	        System.out.println(array[3]);
	    }
	
	    public interface ListArrayConvertor {
	
	        R[] buildArray(int length);
	
	        default R[] listToArray(List list) {
	            R[] array = buildArray(list.size());
	            for (int i = 0; i