我们经常提到，Java8是革命性的一个版本，原因就是正式引入了函数式编程，那Java的函数式编程在实际应用中到底有什么用呢？结合实际的应用，我整理出了函数式在Java的几个经典用途。
缓求值
惰性求值（Lazy evaluation）是在需要时才进行求值的计算方式。惰性求值自然地在数据结构中包含递归，可以以简单的方式表示无限的概念，这种方式有利于程序的模块化。
在Java这种Strict语言中，我们定义了临时变量代码块就会立即运算并且取得结果，而实际上很多结果未必会使用到，就存在不必要的计算，如下面的代码
/**
* 是否是标准或默认工作台
* 理论上仅判断默认工作台即可（因为标准就是默认），此处是兜底一下历史逻辑
*
* @param context
* @return
*/
public boolean isStandardOrDefaultWorkbench(SchemaContext context) {
Supplier<Boolean> isDefaultWorkbench = () -> StringUtils.isNotBlank(context.getDefaultAppUuid())
&& StringUtils.equals(context.getAppUuid(), context.getDefaultAppUuid());
return WorkbenchType.WORKBENCH.equals(context.getWorkbenchType()) || isDefaultWorkbench.get();
}
当我们使用临时变量定义的时候，需要理解计算出代码
StringUtils.isNotBlank(context.getDefaultAppUuid())
&& StringUtils.equals(context.getAppUuid(), context.getDefaultAppUuid())
的值，并用于后面的判断，不管下面的代码是否为True，我们都消耗了一次计算
WorkbenchType.WORKBENCH.equals(context.getWorkbenchType())
而我们使用了Supplier，就可以定义一个匿名表达式，只有当前面判断为False的时候，才会执行
isDefaultWorkbench.get()
，而当前面判断为True的时候，就不会执行后面的代码了，通过缓求值的方式，可以节省在某些情况下的消耗，可以提升系统性能，节省资源。
高阶函数
高阶函数是指使用其他函数作为参数、或者返回一个函数作为结果的函数。
我们常用的Stream就是典型的流处理思想，可以通过Stream来处理集合并执行相关的操作，其中Stream包含了大量的高阶函数，我们可以直接使用匿名表达式来传递业务逻辑。值得注意，匿名表达式本身返回的就是函数，因此匿名表达式就是一种高阶函数。
// 过滤隐藏应用
return appDetails.stream().filter(app -> {
AppModel appModel = new AppModel(app.getAppId(), app.getAppType());
return !appDisplayModel.getHideApps().contains(appModel);
}).collect(Collectors.toList());
从上面可以逻辑可以看到，我们可以通过集合的Stream对象进行filter、map、collect操作，其中这些高阶函数就可以传递lambda表达式，用于处理我们需要的逻辑。
当然除了Stream之外，Java很多工具类也支持外部传入lambda，比如还有一种常见的工具类Optional。
/**
* 获取组织默认工作台appUuid
* @param corpId
* @param orgConfigTag
* @return
*/
public String getDefaultWorkbenchAppUuid(String corpId, OrgConfigTag orgConfigTag) {
return Optional.ofNullable(orgConfigTag).map(OrgConfigTag::getDefaultAppUuid)
.orElseGet(() -> OpenPageUtils.buildWorkbenchAppUuid(corpId));
}
其中的orElseGet方法就支持外部传入lambda表达式。
函数回调
在计算机程序设计中，回调函数，或简称回调（Callback 即call then back 被主函数调用运算后会返回主函数），是指通过参数将函数传递到其它代码的，某一块可执行代码的引用。 这一设计允许了底层代码调用在高层定义的子程序。
函数回调可用于接口两块完全无关的逻辑，比如在A模块执行完毕后，执行B模块，B模块的代码事先在A模块注册。很多框架型的逻辑，比如统一结果处理、缓存框架、分布式锁、线程缓存等都可以通过这个方式来优化，就可以使用lambda的方式来实现。核心的逻辑就是先处理相关的通用的中间件逻辑，然后通过lambda来执行业务逻辑。
/**
* 创建我的页面
*
* @param corpId
* @param uid
*/
protected void createMyPage(String corpId, Long uid, String appUuid, Method method) throws WorkbenchException {
// 并发锁控制
distributeLockSupport.lockAndDo(key,
() -> {
//创建页面方法
userCorpPageSupport.createMyPage(corpId, uid);
return null;
}
);
}
如上面的代码，对于要实现分布式锁控制的模块，可以使用lambda的回调，来实现加锁和业务逻辑的分离。其中的定义如下述代码所示
/**
* 基于缓存的分布式锁操作
*
* @param key 资源key
* @param callback 回调函数
* @param 返回结果类型
* @return
* @throws Exception
*/
public T lockAndDo(String key, Callback callback) throws WorkbenchException {
//取锁
...
try {
//加锁
...
return callback.process();
} catch (WorkbenchException ex) {
throw ex;
} finally {
try {
//释放锁
...
} catch (Exception ex) {
//异常处理
}
}
}
//回调接口定义，供外部传入lambda
@FunctionalInterface
public interface Callback {
/**
* 回调处理
*
* @return 处理结果
* @throws WorkbenchException
*/
T process() throws WorkbenchException, ServiceException;
}
自定义函数
从函数式编程的核心思想来说，函数是一等公民，而面向对象的核心是封装。可以通过定义函数的方式来降低面向对象命令式编程的复杂度。即尽量把处理逻辑都抽象成可复用的函数，并通过lambda的方式进行调用。
/**
* 批量操作
*
* @param consumer 函数式写法，对批量对象操作
*/
public void batchProccess(BiConsumer consumer) {
if(orchardDTOMap!=null && orchardDTOMap.size()>0){
for (Map.Entry entry : orchardDTOMap.entrySet()) {
consumer.accept(entry.getKey(), entry.getValue());
}
}
}
public void syncPush(MicroAppContext context, BatchOrchardDTO batchOrchardDTO) {
//传入lambda来执行逻辑
batchOrchardDTO.batchProccess((k, v) -> pushFacadeService.push(k, v));
}
如上图所示，就是在类中定义了一个高阶函数，在调用的时候从外部传入lambda表达式，从而实现batchProccess和pushFacadeService.push两个方法的解耦。上面的核心和集合支持lambda是一个意思，也就是把需要外部频繁操作的部分抽象出来定义成函数式接口，以供外部传入不同的lambda进行丰富的操作。
总结
Java8非常重要的就是引入了函数式编程的思想，使得这门经典的面向对象语言有了函数式的编程方式。弥补了很大程度上的不足，函数式思想在处理复杂问题上有着更为令人称赞的特性。