【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<int[]> comparator = int[]::new;
        int[] compare = comparator.length(10);
        System.out.println(compare.length);
    }

    public interface AddressComparator<R> {
        R length(int arg);
    }
}

数组构造方法式lambda一个很重要的用途，就是可以用来创建泛型数组

public class Test {

    private static final List<String> list = new ArrayList();

    static {
        list.add("item");
        list.add("item");
        list.add("item");
        list.add("item");
    }

    public static void main(String[] args) {
        ListArrayConvertor<String> convertor = String[]::new;
        String[] array = convertor.listToArray(list);
        System.out.println(array[3]);
    }

    public interface ListArrayConvertor<R> {

        R[] buildArray(int length);

        default R[] listToArray(List<R> list) {
            R[] array = buildArray(list.size());
            for (int i = 0; i < list.size(); i++)
                array[i] = list.get(i);
            return array;
        }
    }
}