Lambda表达式与方法引用

作者简介：大家好，我是smart哥，前中兴通讯、美团架构师，现某互联网公司CTO

联系qq：184480602，加我进群，大家一起学习，一起进步，一起对抗互联网寒冬

引子

先来看一个案例

public class MethodReferenceTest {

    private static final List<Person> list;

    static {
        list = new ArrayList<>();
        list.add(new Person(19));
        list.add(new Person(18));
        list.add(new Person(20));
    }

    public static void main(String[] args) {
        System.out.println(list);
        // sort()方法是List本身就有的，主要用来排序
        list.sort((p1, p2) -> p1.getAge() - p2.getAge());
        System.out.println(list);
    }


    @Data
    @AllArgsConstructor
    static class Person {
        private Integer age;
    }

}

结果

排序前：

[MethodReferenceTest.Person(age=19), MethodReferenceTest.Person(age=18), MethodReferenceTest.Person(age=20)]

排序后：

[MethodReferenceTest.Person(age=18), MethodReferenceTest.Person(age=19), MethodReferenceTest.Person(age=20)]

把上面的案例稍作改动：

public class MethodReferenceTest {

    private static final List<Person> list;

    static {
        list = new ArrayList<>();
        list.add(new Person(19));
        list.add(new Person(18));
        list.add(new Person(20));
    }

    public static void main(String[] args) {
        System.out.println(list);
        // 改动2：既然Person内部有个逻辑一样的方法，就用它来替换Lambda
        list.sort(Person::compare);
        System.out.println(list);
    }

    @Data
    @AllArgsConstructor
    static class Person {
        private Integer age;

        // 改动1：新增一个方法，逻辑和之前案例的Lambda表达式相同
        public static int compare(Person p1, Person p2) {
            return p1.getAge() - p2.getAge();
        }
    }
}

嗯？这是什么操作？不急，接着往下看。

从Lambda到方法引用

大家在《Lambda表达式》一文中应该看过下面这段代码：

/**
 * 从匿名对象 到Lambda 再到方法引用
 *
 * @author mx
 */
public class MethodReferenceTest {
    public static void main(String[] args) {
        String str1 = "abc";
        String str2 = "abcd";

        // 方式1：匿名对象
        Comparator<String> comparator1 = new Comparator<String>() {
            @Override
            public int compare(String o1, String o2) {
                return o1.length() - o2.length();
            }
        };
        compareString(str1, str2, comparator1);


        // 方式2：过渡为Lambda表达式
        Comparator<String> comparator2 = (String s1, String s2) -> {
            return s1.length() - s2.length();
        };
        compareString(str1, str2, comparator2);

        // 方式2的改进版：省去赋值操作，直接把整个Lambda表达式作为参数丢进去
        compareString(str1, str2, (String s1, String s2) -> {
            return s1.length() - s2.length();
        });

        // 方式2的最终版：把变量类型和return也去掉了，因为Java可以自动推断
        compareString(str1, str2, (s1, s2) -> s1.length() - s2.length());


        // 方式3：换种比较方式，本质和方式2是一样的，不信你去看看String#compareTo()
        Comparator<String> comparator3 = (s1, s2) -> s1.compareTo(s2);


        // 方式4：IDEA提示有改进的写法，最终变成了方法引用
        compareString(str1, str2, String::compareTo);

        // 完美。

    }

    /**
     * 传递Comparator，对str1和str2进行比较
     *
     * @param str1
     * @param str2
     * @param comparator
     */
    public static void compareString(String str1, String str2, Comparator<String> comparator) {
        System.out.println(comparator.compare(str1, str2));
    }
}

很多初学者肯定崩溃了：Lambda已经够抽象了，好不容易从匿名对象过渡到Lambda，怎么又突然冒出String::compareTo这鬼东西？！

我们在学习Lambda时，把它和匿名类作比较。因为匿名类和Lambda处理的逻辑是一样的，所以就用Lambda简化了匿名类：

同样的，如果项目中已经定义了相同逻辑的方法，我们为什么还要再写一遍呢？即使Lambda表达式再怎么简洁，终究还是要手写好几行代码。

所以，JDK在Lambda表达式的基础上又提出了方法引用的概念，允许我们复用当前项目（或JDK源码）中已经存在的且逻辑相同的方法。

比如上面那个例子中的：

// 方式3：换种比较方式，本质和方式2是一样的
Comparator<String> comparator3 = (s1, s2) -> s1.compareTo(s2);

// 方式4：IDEA提示有改进的写法，最终变成了方法引用
compareString(str1, str2, String::compareTo);

String::compareTo看起来形式有点诡异，但这只是一种语法而已，习惯就好了，关键是明白它代表什么意思。Java8引入::符号，用来表示方法引用。所谓的方法引用，就是把方法搬过来使用。那么，String::compareTo把哪个类的什么方法搬过来了呢？

一般来说，String类定义的compareTo方法的正常使用方式是这样的：

public class MethodReferenceTest {
    public static void main(String[] args) {
        String str = "hello";
        String anotherStr = "world";
        int difference = str.compareTo(anotherStr);
    }
}

作为更高阶的Lambda表达式，方法引用也能作为参数传递，于是就有了：

public class MethodReferenceTest {
    public static void main(String[] args) {
        String str = "hello";
        String anotherStr = "world";

        // 匿名内部类
        Comparator<String> comparator = new Comparator<String>() {
            @Override
            public int compare(String str, String anotherStr) {
                return str.compareTo(anotherStr);
            }
        };

        // 方法引用。上面的str.compareTo(anotherStr)不就是String::compareTo吗！！
        Comparator<String> newComparator = String::compareTo;

        compareString(str, anotherStr, newComparator);
    }

    /**
     * 传递Comparator，对str1和str2进行比较
     *
     * @param str1
     * @param str2
     * @param comparator
     */
    public static void compareString(String str1, String str2, Comparator<String> comparator) {
        System.out.println(comparator.compare(str1, str2));
    }
}

总之，Java8的意思就是：

兄弟，如果已经存在某个方法能完成你的需求，那么你连Lambda表达式都别写了，直接引用这个方法吧。

但我个人更推荐Lambda表达式，原因有两个：

• 对初学者而言，Lambda表达式语义更清晰、更好理解
• Lambda表达式细粒度更小，能完成更精细的需求

第一点，你懂的。

第二点，请容许我来证明一下。

Lambda表达式VS方法引用

/**
 * MyPredict是模拟Predict
 * MyInteger是模拟Integer
 * <p>
 * 本次测试的目的旨在说明：Lambda毕竟是手写的，自由度和细粒度要高于方法引用。
 *
 * @author sunting
 */
public class MethodAndLambdaTest {
    public static void main(String[] args) {
        // 1.匿名对象
        MyPredict myPredict1 = new MyPredict() {
            @Override
            public boolean test(int a, int b) {
                return a - b > 0;
            }
        };
        boolean result1 = myPredict1.test(1, 2); // false

        // 2.从匿名对象过渡到Lambda表达式
        MyPredict myPredict2 = (a, b) -> a - b > 0;
        myPredict2.test(1, 2); // false

        // 3.MyInteger#compare()的方法体和上面的Lambda表达式逻辑相同，可以直接引用
        MyPredict myPredict3 = MyInteger::compare;
        myPredict3.test(1, 2); // false

        // 4.Lambda说，你想模仿我？想得美！老子要DIY一下比较规则（a减b 变成了 b减a）
        MyPredict myPredict4 = (a, b) -> b - a > 0;
        myPredict4.test(1, 2); // true

        // 5.看到这，方法引用不服气，也想DIY一把
        MyPredict myPredict5 = MyInteger::compare;
        // ???，没法DIY，MyInteger::compare是把整个方法搬过来，不能修改内部的逻辑
    }
}

interface MyPredict {
    boolean test(int a, int b);
}

class MyInteger {
    public static boolean compare(int a, int b) {
        return a - b > 0;
    }
}

方法引用，其实就是把现成的某个方法拿来替代逻辑相似的Lambda表达式。

但Lambda表达式由(a, b) -> a - b > 0 变为 (a, b) -> b - a > 0 ，说明Lambda逻辑已经变了，此时原先的方法引用就不匹配了，不能再用了。此时我们最自然的想法应该是从现成的项目中找到逻辑和(a, b) -> b - a > 0相同的另一个方法，然后把那个方法引用过来，而不是想着改变原来的MyInteger::Compare，那不是你的方法，你也只是借用而已！！

所以，我们给MyInteger加一个方法吧：

class MyInteger {
    public static boolean compare(int a, int b) {
        return a - b > 0;
    }

    public static boolean anotherCompare(int a, int b) {
        return b - a > 0;
    }
}

这样，方法引用的逻辑又和Lambda匹配了：

public class MethodAndLambdaTest {
    public static void main(String[] args) {

        MyPredict myPredict2 = (a, b) -> a - b > 0;
        myPredict2.test(1, 2); // false

        MyPredict myPredict3 = MyInteger::compare;
        myPredict3.test(1, 2); // false

        MyPredict myPredict4 = (a, b) -> b - a > 0;
        myPredict4.test(1, 2); // true
		
        // MyInteger::anotherCompare的逻辑和上面的Lambda才是匹配的
        MyPredict myPredict5 = MyInteger::anotherCompare;
        myPredict5.test(1, 2); // true
    }

}

interface MyPredict {
    boolean test(int a, int b);
}

class MyInteger {
    public static boolean compare(int a, int b) {
        return a - b > 0;
    }

    public static boolean anotherCompare(int a, int b) {
        return b - a > 0;
    }
}

再看一个Stream API的例子：

filter此时需要的逻辑是：年龄大于等于30岁的teacher。

你能从现有项目中找到逻辑为“年龄大于等于30岁的teacher”的方法吗？

答案是没有。

你最多只能调用Teacher::getAge()，但是这个方法引用的逻辑是“获取老师的年龄”，而不是“是否大于等于30岁”，两者逻辑不同，无法替换。

那能不能使用 Teacher::getAge()>=30 呢？

答案是不能。

首先，filter()的参数要么是Lambda表达式，要么是方法引用，不能是方法引用+语句，不伦不类。

其次，也是最重要的，你可以认为Teacher::getAge表示

public Integer getAge(){
    return this.age;
}

中的return this.age;，它是一个语句。我们可以对表达式叠加判断，比如 a-b ，我们可以继续叠加变成 a-b+c。但是 int d = a-b+c; 已经没办法再叠加了，因为 int d = a-b+c; >= 30 是不可接受的！

处理办法也简单，就是找一个相同逻辑的方法并引用它。假设存在以下方法：

public boolean isBiggerThan30(){
    return this.age >= 30;
}

那就可以写成：

list.stream().filter(Teacher::isBiggerThan30);

后话

关于方法引用其实还可以展开说，比如可以分为：

• 静态方法引用（Integer::compare）
• 实例方法引用（this::getName、user::getName）
• 构造器方法引用（User::new）

总体来说，方法引用（包括构造器引用）的前提是，函数式接口的方法对应的参数列表和返回值 与 引用类定义的方法的参数列表和返回值 一致。这样说可能比较绕，这里举一个demo：

public class StreamConstructorTest {

    public static void main(String[] args) {

        // 下面4个语句都是Person::new，却能赋值给不同的函数式接口
        // 原因是：每个函数式接口都能从Person类中找到对应的方法（参数列表一致），从而完成方法引用
        PersonCreatorNoConstruct person1 = Person::new;

        // 大家可以尝试把Person中Age构造函数注释，那么下面的赋值语句会提示错误，因为此时不存在只有一个age参数的构造器！
        PersonCreatorWithAge person2 = Person::new;

        PersonCreatorWithName person3 = Person::new;

        PersonCreatorAllConstruct person4 = Person::new;

    }


    public interface PersonCreatorNoConstruct {
        // 对应Person无参构造
        Person create();
    }

    public interface PersonCreatorWithAge {
        // 对应Person的age构造函数
        Person create(Integer age);
    }

    public interface PersonCreatorWithName {
        // 对应Person的name构造函数
        Person create(String name);
    }

    public interface PersonCreatorAllConstruct {
        // 对应Person的全参构造函数
        Person create(Integer age, String name);
    }

    @Getter
    @Setter
    static class Person {
        private Integer age;
        private String name;

        public Person() {
        }

        public Person(Integer age) {
            this.age = age;
        }

        public Person(String name) {
            this.name = name;
        }

        public Person(Integer age, String name) {
            this.age = age;
            this.name = name;
        }
    }
}

但无论是方法引用还是构造器引用，都是细枝末节的东西，本质上学习好Lambda表达式即可。我对方法引用/构造器引用的态度就一个：如果我的代码不是最优，让IDEA提醒我便是，我反正是懒得记~

作者简介：大家好，我是smart哥，前中兴通讯、美团架构师，现某互联网公司CTO

进群，大家一起学习，一起进步，一起对抗互联网寒冬

代码007普通

打赏 收藏 海报 链接