企业网站的建设与实现,乌镇网站开发文档,泰州市城市建设网站,推广措施作者简介#xff1a;大家好#xff0c;我是smart哥#xff0c;前中兴通讯、美团架构师#xff0c;现某互联网公司CTO 联系qq#xff1a;184480602#xff0c;加我进群#xff0c;大家一起学习#xff0c;一起进步#xff0c;一起对抗互联网寒冬 引子
先来看一个案例 …作者简介大家好我是smart哥前中兴通讯、美团架构师现某互联网公司CTO 联系qq184480602加我进群大家一起学习一起进步一起对抗互联网寒冬 引子
先来看一个案例
public class MethodReferenceTest {private static final ListPerson 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);}DataAllArgsConstructorstatic class Person {private Integer age;}}
结果
排序前
[MethodReferenceTest.Person(age19), MethodReferenceTest.Person(age18), MethodReferenceTest.Person(age20)] 排序后
[MethodReferenceTest.Person(age18), MethodReferenceTest.Person(age19), MethodReferenceTest.Person(age20)] 把上面的案例稍作改动
public class MethodReferenceTest {private static final ListPerson 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内部有个逻辑一样的方法就用它来替换Lambdalist.sort(Person::compare);System.out.println(list);}DataAllArgsConstructorstatic 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匿名对象ComparatorString comparator1 new ComparatorString() {Overridepublic int compare(String o1, String o2) {return o1.length() - o2.length();}};compareString(str1, str2, comparator1);// 方式2过渡为Lambda表达式ComparatorString 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()ComparatorString comparator3 (s1, s2) - s1.compareTo(s2);// 方式4IDEA提示有改进的写法最终变成了方法引用compareString(str1, str2, String::compareTo);// 完美。}/*** 传递Comparator对str1和str2进行比较** param str1* param str2* param comparator*/public static void compareString(String str1, String str2, ComparatorString comparator) {System.out.println(comparator.compare(str1, str2));}
}
很多初学者肯定崩溃了Lambda已经够抽象了好不容易从匿名对象过渡到Lambda怎么又突然冒出String::compareTo这鬼东西 我们在学习Lambda时把它和匿名类作比较。因为匿名类和Lambda处理的逻辑是一样的所以就用Lambda简化了匿名类 同样的如果项目中已经定义了相同逻辑的方法我们为什么还要再写一遍呢即使Lambda表达式再怎么简洁终究还是要手写好几行代码。 所以JDK在Lambda表达式的基础上又提出了方法引用的概念允许我们复用当前项目或JDK源码中已经存在的且逻辑相同的方法。 比如上面那个例子中的
// 方式3换种比较方式本质和方式2是一样的
ComparatorString comparator3 (s1, s2) - s1.compareTo(s2);// 方式4IDEA提示有改进的写法最终变成了方法引用
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;// 匿名内部类ComparatorString comparator new ComparatorString() {Overridepublic int compare(String str, String anotherStr) {return str.compareTo(anotherStr);}};// 方法引用。上面的str.compareTo(anotherStr)不就是String::compareTo吗ComparatorString newComparator String::compareTo;compareString(str, anotherStr, newComparator);}/*** 传递Comparator对str1和str2进行比较** param str1* param str2* param comparator*/public static void compareString(String str1, String str2, ComparatorString 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() {Overridepublic 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减aMyPredict myPredict4 (a, b) - b - a 0;myPredict4.test(1, 2); // true// 5.看到这方法引用不服气也想DIY一把MyPredict myPredict5 MyInteger::compare;// ???没法DIYMyInteger::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); // falseMyPredict myPredict3 MyInteger::compare;myPredict3.test(1, 2); // falseMyPredict 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-bc。但是 int d a-bc; 已经没办法再叠加了因为 int d a-bc; 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);}GetterSetterstatic 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 进群大家一起学习一起进步一起对抗互联网寒冬
