【高手问答第 305 期精华汇总】 —— 如何使用 lambda 表达式提升开发效率？

嘉宾介绍

问：想使用 自定义函数式接口 解决跨版本兼容问题，例如不同版本的jar api不一致，但是要兼容低版本和高版本就想着用这个。有什么改动最小的方法？

答：可以封装一个函数例如

  public static void execute(Map<org.dromara.streamquery.stream.core.enums.JreEnum, Runnable> jdkVersionStragyMap) { jdkVersionStragyMap.forEach((key, value) -> { if (key.isCurrentVersion()) { value.run(); } }); }

使用时指定不同的策略：

  Map<JreEnum, Runnable> jdkVersionStragyMap = new HashMap<>(); jdkVersionStragyMap.put(JreEnum.JAVA_8, () -> System.out.println("java8")); jdkVersionStragyMap.put(JreEnum.JAVA_9, () -> System.out.println("java9")); jdkVersionStragyMap.put(JreEnum.JAVA_10, () -> System.out.println("java10")); execute(jdkVersionStragyMap);

上述使用的JreEnum在http://stream-query.dromara.org/ 中存在

问：能介绍一下 Collector 吗？它是五个方法是干嘛的？三个泛型又代表什么意思？

答：首先介绍下Collector：

https://docs.oracle.com/javase/8/docs/api/java/util/stream/Collector.html

Collector通常是作为Stream的collect方法的参数，通过使用Collectors可以创建一些预设的Collector例如上方提到的

 list.stream().collect(Collectors.toList())

则是将流转换收集起来为List集合，Collectors还预设了非常多的常用收集器，基本满足大多数场景如Collectors.toMap、Collectors.groupingBy等，此处回答不做过多展开，继续回答一下Collector的五个方法，除了characteristics以外，其他四个方法均返回函数式接口

1. supplier ，意义是用于指定初始值，也可用于指定具体类型，可以传入lambda表达式如：

HashMap::new、()-> new ArrayList(88)等

2. accumulator，返回值是BiConsumer类型，意义为传入具体的收集操作，例如此处的lambda包含两个参数为

map（需要收集到的map）和item(每一个元素)

逻辑为将item.toString作为key，item作为value放入map

 (map, item) -> { map.put(item.toString(), item); } 

3. combiner，返回BinaryOperator类型的函数式接口，是一个可选的参数，可选不一定代表可以传入null，而指的是lambda中可以随便写，例如传入(lastMap, curMap) -> null

这个参数的意义是在“并行流”场景下，将多线程返回的多个结果进行合并，如果是“串行流”，则不会调用lambda中的方法。此处讲一下并行流和串行流：

因为Stream流只有在 结束操作(collect、reduce、forEach等) 时才会真正触发执行以往的 中间操作 (filter、map、flatMap等)

它分为串行流和并行流 并行流会使用拆分器(java.util.Spliterator)将操作拆分为多个异步任务(java.util.concurrent.ForkJoinTask)执行 这些异步任务默认使用(java.util.concurrent.ForkJoinPool)线程池进行管理

拆分后的任务，由于是异步并行执行，所以每个异步任务会返回一个结果，宏观就是会返回多个结果，最终将这些结果收集起来，所以需要使用combiner，使用例子：

  (lastMap, curMap) -> { lastMap.putAll(curMap); return lastMap; }

如果只是在串行流(同步场景)使用，这个参数对应的lambda就不会执行

4. finisher，意义为最终转换，返回Function，是在收集结束后执行，例：

  map -> { return Collections.unmodifiableMap(map); }

不一定是相同类型，不同类型也可以

  map -> { return map.values(); }

5.  characteristics，表示特征，返回值是一个Set，里面装着Characteristics类型的枚举

CONCURRENT允许并发执行的

UNORDERED没有指定特定的顺序的

IDENTITY_FINISH中间步骤和结束步骤一致

这部分主要是用于描述特征，在执行时如果有相应的特征，会走相应的执行流程

然后是三个泛型

T: 元素类型，流里的每一个元素的具体类型

A: 中间类型，用于收集元素的对象/集合的类型

R: 最终类型，通常和中间类型一致，但如果有最终操作finisher，会改变最终类型

这里列举一个完整用法：

  Collector<Object, Map<String, Object>, Map<String, Object>> mapCollector = Collector.of(HashMap::new, (map, item) -> map.put(item.toString(), item), (lastMap, curMap) -> { lastMap.putAll(curMap); return lastMap; }, Collections::unmodifiableMap, Collector.Characteristics.IDENTITY_FINISH); Map<String, Object> map = Stream.of(1, 2, 3).collect(mapCollector);

问：

 stream().parallel()

这个方法适用于大数据么？

答：并行流一般用于中间操作较为耗时的场景使用，例如 files.parallelStream().map(f -> { // 文件读取/文件压缩等等... }).collect(Collectors.toList()); 对于中间操作(filter、map、flatMap等)耗时不太长的情况下性能帮助不大

问：使用匿名表达式对于性能和匿名类之间有多大提升？

答：匿名表达式（Lambda）会比匿名类稍快，理由是通常不会导致新类的生成和加载，但这一点点快，在JIT的优化加持下，完全可以忽略不计

问：JDK 8 里面的 Lambda/Stream 除了可以方便编写一些匿名函数，更偏向于函数式编程风格的代码外，还有没有其他亮点，代码执行效率怎么样，有没有什么最佳实践指南，如何在项目团队中推广？

答：还可以用lambda序列化，在编译检测的情况下使用例如User::getName代替"name"，避免人员编写错误 还可以使用lambda代替反射提升性能，如fastjson就广泛使用这一技巧。相关指南可以参考相关的规范链接： https://flink.apache.org/zh/how-to-contribute/code-style-and-quality-java/#lambdas

推广的话，可以多多列举一些对比，例如相同的功能，不用lambda是多少行、用了后是多少行之类的。

问：请问在日常使用的情况下，在自己的项目中如何充分运用自己写的函数式接口，与一些设计模式进行配合呢

答：可以在策略模式中灵活运用lambda表达式，简化代码

例如按照我以往讲策略模式blog中的例子：

https://vampireachao.gitee.io/2021/10/16/%E7%AD%96%E7%95%A5%E6%A8%A1%E5%BC%8F/

  Navigator navigator = new Navigator(new WalkingStrategy());

 Navigator navigator = new Navigator((s, e) -> Arrays.asList("先倒1", "路寸2", "途泾3"));

Lambda 表达式

https://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html

简单来说：就是把我们的函数 (方法) 作为参数传递、调用等

例子：自定义函数式接口（用 jdk 自带的函数式接口也可以）

 import java.io.Serializable; /** * 可序列化的Functional * * @author VampireAchao */ @FunctionalInterface public interface Func<T, R> extends Serializable { /** * 调用 * * @param t 参数 * @return 返回值 */ R apply(T t); } 

我们定义一个类可以去实现该接口

 /** * 可序列化的函数式接口实现类 * * @author VampireAchao */ public class FuncImpl implements Func<Object, String> { /** * 调用 * * @param o 参数 * @return 返回值 */ @Override public String apply(Object o) { return o.toString(); } } 

到此为止，都非常的简单

这里就有个问题：假设我有很多的地方需要不同的类去实现 Func，我就得每次都去写这么一个类，然后实现该接口并重写方法

这样很麻烦！因此我们使用匿名内部类

  Func<String, Integer> func = new Func<String, Integer>() { /** * 调用 * * @param s 参数 * @return 返回值 */ @Override public Integer apply(String s) { return s.hashCode(); } }; 

我们可以看到，使用了匿名内部类后不用每次去新建这个类了，只需要在调用的地方，new 一下接口，创建一个匿名内部类即可

但这样还有个问题，我们每次都要写这么一大几行代码，特别麻烦

由此而生，我们有了 lambda 这种简写的形式

https://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html#syntax

  Func<String, String> func1 = (String s) -> { return s.toUpperCase(); }; 

如果只有一行，我们可以省略掉中括号以及 return

  Func<String, String> func2 = (String s) -> s.toUpperCase(); 

我们可以省略掉后边的参数类型

  Func<String, String> func3 = s -> s.toUpperCase(); 

如果我们满足特定的形式，我们还可以使用方法引用（双冒号）的形式缩写

  Func<String, String> func4 = String::toUpperCase; 

这里除了我们的参数->返回值写法：s->s.toUpperCase()，还有很多种

例如无参数带返回值写法 ()->"yes"、无参无返回值写法 ()->{} 等等

而方法引用这种写法有如下几种：

https://docs.oracle.com/javase/tutorial/java/javaOO/methodreferences.html

 package org.dromara.streamquery; import java.util.function.Function; import java.util.function.IntFunction; import java.util.function.Supplier; /** * 语法糖——方法引用 * * @author VampireAchao */ 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]; // intFunc == new int[20]; 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; } } 

顺便放几个常用的，jdk 自带的函数式接口写法

 package org.dromara.streamquery; import java.math.BigDecimal; import java.util.function.*; /** * 常用的几个函数式接口写法 * * @author VampireAchao */ class Usual { public static Consumer<Object> consumer() { // 有参数无返回值 return o -> { }; } public static Function<Integer, Object> function() { // 有参数有返回值 return o -> o; } public static Predicate<Object> predicate() { // 有参数，返回值为boolean 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，可以让你以一种声明的方式处理数据。方法全是传入函数作为参数，来达到我们的目的。

https://docs.oracle.com/javase/8/docs/api/java/util/stream/package-summary.html

  // 声明式编程是告诉计算机需要计算“什么”而不是“如何”去计算 // 现在，我想要一个List，包含3个数字6 List<Integer> sixSixSix = // 我想要： Stream // 数字6 .generate(() -> 6) // 3个 .limit(3) // 最后收集起来转为List .collect(Collectors.toList()); sixSixSix.forEach(System.out::print);