不速之客只在告辞以后才最受欢迎——莎士比亚
公众号链接:https://mp.weixin.qq.com/s/MFXRBr16LuGn6G2rlOFFEw
简介
今天主要聊聊java
中的lambda
距离我加入hutool-commiter
已经有一段时间了,想起曾经封装过的一个类Opt
,就是使用lambda
,按照惯例,先介绍下dromara
组织下的项目hutool
Hutool是一个小而全的Java工具类库,通过静态方法封装,降低相关API的学习成本,提高工作效率,使Java拥有函数式语言般的优雅,让Java语言也可以“甜甜的”。
这个类Opt
的灵感来源是对jdk
内置的java.util.Optional
的拓展,在一些细节方面进了了简化处理
下面主要是通过其介绍lambda
的使用
快速上手
依靠idea
编译器的提示进行快速上手
下方是判断user
是否为空,不为空通过User#getSchool()
获取学校名的操作
例如此处我写到这里
1 2 3 4 User user = new User (); |Function<? super User,?> mapper| Opt.ofNullable(user).map()
这里idea
为我们提示了参数类型,可这个Function
我也不知道它是个什么
实际上,我们new
一个就好了
1 2 3 Opt.ofNullable(user).map(new Fun ) |Function<User, Object>{...} (java.util.function) | <-戳我 |Func<P,R> cn.hutool.core.lang.func |
这里idea
提示了剩下的代码,我们选Function
就行了,接下来如下:
1 2 Opt.ofNullable(user).map(new Function <User, Object>() { })
我们这里根据具体操作选取返回值
例如这里是想判断user
是否为空,不为空时调用getSchool
,从而获取其中的返回值String
类型的school
我们就如下写法,将第二个泛型,也就是象征返回值的泛型改为String
:
1 2 Opt.ofNullable(user).map(new Function <User, String>() { })
然后这里红线提示了,我们就使用idea
的修复所有,默认快捷键alt
+回车
1 2 3 4 Opt.ofNullable(user).map(new Function <User, String>() { }) | 💡 Implement methods | <-选我 | ✍ Introduce local variable | | ↩ Rollback changes in current line |
选择第一个Implement methods
即可,这时候弹出一个框,提示让你选择你想要实现的方法
这里就选择我们的apply
方法吧,按下一个回车就可以了,或者点击选中apply
,再按一下OK
按钮
1 2 3 4 5 6 7 8 9 10 11 12 13 ||IJ| Select Methods to Implement X | | | | 👇 © | ↹ ↸ | | -------------------------------------------------------- | | | java.util.function.Function | | | ⒨ 🔓 apply(t:T):R | <-选我选我 | | ⒨ 🔓 compose(before:Function<? super V,? extents T):Fu| | | ⒨ 🔓 andThen(after:Function<? super R,? extends V >):Fu| | | | | | ======================================== | | -------------------------------------------------------- | | ☐ Copy JavaDoc | | ☑ Insert @Override | OK | | CANCEL | | <-选完点我点我
此时此刻,代码变成了这样子
1 2 3 4 5 6 Opt.ofNullable(user).map(new Function <User, String>() { @Override public String apply (User user) { return null ; } })
这里重写的方法里面就写你自己的逻辑(别忘了补全后面的分号)
1 2 3 4 5 6 Opt.ofNullable(user).map(new Function <User, String>() { @Override public String apply (User user) { return user.getSchool(); } });
我们可以看到,上边的new Function<User, String>()
变成了灰色
我们在它上面按一下alt
+enter
(回车)
1 2 3 4 5 6 Opt.ofNullable(user).map(new Function <User, String>() { @Override | 💡 Replace with lambda > | <-选我啦 public String apply (User user) { | 💡 Replace with method reference > | return user.getSchool(); | 💎 balabala... > | } });
选择第一个Replace with lambda
,就会自动缩写为lambda
啦
1 Opt.ofNullable(user).map(user1 -> user1.getSchool());
如果选择第二个,则会缩写为我们双冒号格式
1 Opt.ofNullable(user).map(User::getSchool);
接下来我们获取值即可
1 2 3 4 5 6 7 String school = Opt.ofNullable(user).map(User::getSchool).get();String school = Opt.ofNullable(user).map(User::getSchool).orElse("NO_SCHOOL" );String school = Opt.ofNullable(user).map(User::getSchool).orElseGet(() -> User.getDefaultSchool());
进阶
简单来说:函数式编程就是把我们的函数(方法)作为参数/变量传递、调用等,有点像反射的Method
对象,都是作为函数的载体
例子:自定义函数式接口
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 import java.io.Serializable;@FunctionalInterface public interface Func <T, R> extends Serializable { R apply (T t) ; }
我们定义一个类可以去实现该接口
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 public class FuncImpl implements Func <Object, String> { @Override public String apply (Object o) { return o.toString(); } }
这里就有个问题:假设我有很多的地方需要不同的类去实现Func
,我就得每次都去写这么一个类,然后实现该接口并重写方法
这样很麻烦!因此我们使用匿名内部类
1 2 3 4 5 6 7 8 9 10 11 12 Func<String, Integer> func = new Func <String, Integer>() { @Override public Integer apply (String s) { return s.hashCode(); } };
我们可以看到,使用了匿名内部类后不用每次去新建这个类了,只需要在调用的地方,new
一下接口,创建一个匿名内部类即可
但这样还有个问题,我们每次都要写这么一大堆,特别麻烦
由此而生,我们有了lambda
这种简写的形式
1 2 3 Func<String, String> func1 = (String s) -> { return s.toUpperCase(); };
如果只有一行,我们可以省略掉中括号以及return
1 Func<String, String> func2 = (String s) -> s.toUpperCase();
我们可以省略掉后边lambda
中的参数类型,因为前面已经定义过了,编译器能自动推断
1 Func<String, String> func3 = s -> s.toUpperCase();
如果我们满足特定的形式,我们还可以使用双冒号的形式缩写
1 Func<String, String> func4 = String::toUpperCase;
这里除了我们的参数->返回值
写法:s->s.toUpperCase()
,还有很多种
例如无参数带返回值写法()->"yes"
、无参无返回值写法()->{}
等等
而双冒号这种写法至少有如下几种:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 package com.ruben;import java.util.function.Function;import java.util.function.IntFunction;import java.util.function.Supplier;public class MethodReferences { public static Object staticSupplier () { return "whatever" ; } public Object instanceSupplier () { return "whatever" ; } public Object anonymousInstanceFunction () { return "whatever" ; } public static void main (String[] args) { Supplier<MethodReferences> conSup = () -> new MethodReferences (); conSup = MethodReferences::new ; IntFunction<int []> intFunction = value -> new int [value]; int [] intFuncResult = intFunction.apply(20 ); Supplier<Object> statSup = () -> staticSupplier(); statSup = MethodReferences::staticSupplier; Object statSupResult = statSup.get(); Supplier<Object> instSup = new MethodReferences ()::instanceSupplier; instSup = new MethodReferences ()::instanceSupplier; Object instSupResult = instSup.get(); Function<MethodReferences, Object> anonInstFunc = streamDemo -> streamDemo.anonymousInstanceFunction(); anonInstFunc = MethodReferences::anonymousInstanceFunction; } }
顺便放几个常用的函数式接口写法
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 package com.ruben;import java.math.BigDecimal;import java.util.function.*;class Usual { public static Consumer<Object> consumer () { return o -> { }; } public static Function<Integer, Object> function () { return o -> o; } public static Predicate<Object> predicate () { return o -> true ; } public static Supplier<Object> supplier () { return Object::new ; } public static BiConsumer<String, Integer> biConsumer () { return (q, o) -> { }; } public static BiFunction<Integer, Long, BigDecimal> biFunction () { return (q, o) -> new BigDecimal (q).add(BigDecimal.valueOf(o)); } public static UnaryOperator<Object> unaryOperator () { return q -> q; } public static BinaryOperator<Object> binaryOperator () { return (a, o) -> a; } }
Stream介绍
Java 8 API
添加了一个新的抽象称为流Stream
,可以让你以一种声明的方式处理数据。方法全是传入函数作为参数,来达到我们的目的。
1 2 3 4 5 6 7 8 9 10 11 12 List<Integer> list = Stream .generate(() -> 8 ) .limit(3 ) .collect(Collectors.toList());
Stream
使用一种类似用 SQL
语句从数据库查询数据的直观方式来提供一种对 Java
集合运算和表达的高阶抽象。
1 2 3 4 5 6 7 8 9 10 11 12 13 List<String> list = Arrays.asList("dromara" , "Hmily" , "Hutool" , "Sa-Token" , "Jpom" , "TLog" , "Cubic" , "Koalas-rpc" , "Fast Request" ); list = list.stream() .sorted(Comparator.reverseOrder()) .skip(4 ) .limit(4 ) .collect(Collectors.toList());
Stream API
可以极大提高Java
程序员的生产力,让程序员写出高效率、干净、简洁的代码。
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 private static List<String> oldFunc () { List<Integer> list = Arrays.asList(8 , 8 , 8 ); List<String> stringList = new ArrayList <>(list.size()); for (Integer integer : list) { stringList.add(String.valueOf(integer)); } return stringList; } private static List<String> newFunc () { return Stream.generate(() -> 8 ).limit(3 ).map(String::valueOf).collect(Collectors.toList()); }
生成26
个大写字母组成的集合
1 2 List<Character> abc = Stream.iterate('A' , i -> (char ) (i + 1 )).limit(26 ).collect(Collectors.toList());
这种风格将要处理的元素集合看作一种流, 流在管道中传输, 并且可以在管道的节点上进行处理, 比如筛选, 排序,聚合等。
1 2 3 4 5 6 7 8 9 10 int pipe = abc.stream() .filter(i -> i > 'G' ) .sorted(Comparator.reverseOrder()) .mapToInt(Object::hashCode) .sum();
元素流在管道中经过中间操作(intermediate operation
)的处理,最后由最终操作(terminal operation
)得到前面处理的结果。
1 2 3 4 5 6 7 List<String> terminalOperation = abc.stream() .map(String::valueOf).map(String::toLowerCase) .collect(Collectors.toList());
EasyStream
这是即将推出的hutool-6.x
新特新之一,对Stream
进行了进一步简化(设计灵感来源新版jdk
新特性以及日常使用痛点),例如:
1 2 3 4 5 6 7 8 9 10 11 List<String> toList = EasyStream.of(list).map(String::valueOf).toList(); Map<String, Integer> identityMap = EasyStream.of(list).toMap(String::valueOf); List<Integer> list = EasyStream.iterate(0 , i -> i < 3 , i -> i + 1 ).toList(); List<String> list = Arrays.asList("dromara" , "hutool" , "sweet" ); List<String> mapIndex = EasyStream.of(list).mapIdx((e, i) -> i + 1 + "." + e).toList();
当然这个类还在完善中,目前只是一个实验性功能,还存在一些争议和问题,后续优化完成后会开放使用
EasyStream源码链接