0°

Java函数接口实现函数组合及装饰器模式

内容预览:
  • 代码在此,先领会一下 package zzz.study.function.decrator;import jav...~
  • 然后无非是这种形式的组合及嵌套~
  • 显然, -> 符号是右结合优先的~

始发于微信公众号: 程序员小乐

分享编程技能、互联网技术、生活感悟、打造干货分享平台,将总结的技术、心得、经验分享给大家,这里不只限于技术!还有职场心得、生活感悟、以及面经点击上方 “杨守乐” ,选择“置顶公众号”,第一时间送达!


摘要: 通过求解 (sinx)^2 + (cosx)^2 = 1 的若干写法,逐步展示了如何从过程式的写法转变到函数式的写法,并说明了编写“【接受函数参数】并返回【能够接受函数参数的函数】的【高阶函数】”的一点小技巧。

难度: 中级。

代码在此,先领会一下

package zzz.study.function.decrator;
import java.util.Arrays;
import java.util.List;
import java.util.function.BiFunction;
import java.util.function.Function;
import static java.lang.Math.*;
/**
* Created by shuqin on 17/6/29.
*/

public class FunctionImplementingDecrator {
 public static void main(String[] args) {
   // 求解 (sinx)^2 + (cosx)^2 = 1 的若干写法
   double x= 30;
   System.out.println(Math.pow(sin(x),2) + Math.pow(cos(x), 2));
   System.out.println(pow(Math::sin, 2).apply(x) + pow(Math::cos, 2).apply(x));
   double res = op(pow(Math::sin, 2).apply(x), pow(Math::cos, 2).apply(x)).apply((a,b) -> a+b);
   System.out.println(res);
   double res2 = op(pow(Math::sin, 2), pow(Math::cos, 2), x).apply((a,b) -> a+b);
   System.out.println(res2);
   Function<Double,Double> sumSquare = op(pow(Math::sin, 2), pow(Math::cos, 2)).apply((a,b)->a+b);
   System.out.println(sumSquare.apply(x));
   Function<Double,Double> another = op(compose((d)->d*d, Math::sin), compose((d)->d*d, Math::cos)).apply((a,b)->a+b);
   System.out.println(another.apply(x));
   Function<Double,Double> third = compose(d->d*d, d->d+1, d->d*2, d->d*d*d);  // (2x^3+1)^2
   System.out.println(third.apply(3d));
 }
 /** 将指定函数的值封装幂次函数 pow(f, n) = (f(x))^n */
 public static <T> Function<T, Double> pow(final Function<T,Double> func, final int n) {
   return x -> Math.pow(func.apply(x), (double)n);
 }
 /** 对给定的值 x,y 应用指定的二元操作函数 */
 public static <T> Function<BiFunction<T,T,T>, T> op(T x, T y) {
   return opFunc -> opFunc.apply(x, y);
 }
 /** 将两个函数使用组合成一个函数,这个函数接受一个二元操作函数(eg +, -, * , /) */
 public static <T> Function<BiFunction<T,T,T>, T> op(Function<T,T> funcx, Function<T,T> funcy, T x) {
   return opFunc -> opFunc.apply(funcx.apply(x), funcy.apply(x));
 }
 /** 将两个函数组合成一个叠加函数, compose(f,g) = f(g) */
 public static <T> Function<T, T> compose(Function<T,T> funcx, Function<T,T> funcy) {
   return x -> funcx.apply(funcy.apply(x));
 }
 /** 将若干个函数组合成一个叠加函数, compose(f1,f2,...fn) = f1(f2(...(fn))) */
 public static <T> Function<T, T> compose(Function<T,T>... extraFuncs) {
   if (extraFuncs == null || extraFuncs.length == 0) {
     return x->x;
   }
   return x -> Arrays.stream(extraFuncs).reduce(y->y, FunctionImplementingDecrator::compose).apply(x);
 }
 public static <T> Function<BiFunction<T,T,T>, Function<T,T>> op(Function<T,T> funcx, Function<T,T> funcy) {
   //return opFunc -> { return aT -> opFunc.apply(funcx.apply(aT), funcy.apply(aT)); };
   return opFunc -> aT -> opFunc.apply(funcx.apply(aT), funcy.apply(aT));
/*   Equivalent to
   return new Function<BiFunction<T, T, T>, Function<T, T>>() {
     @Override
     public Function<T, T> apply(
         BiFunction<T, T, T> opFunc) {
       return new Function<T, T>() {
         @Override
         public T apply(T aT) {
           return opFunc.apply(funcx.apply(aT), funcy.apply(aT));
         }
       };
     }
   };*/

 }
}

编写“【接受函数参数】并返回【能够接受函数参数的函数】的【高阶函数】”的一点小技巧:直接用 lambda 表达式的角度去思考,辅以数学推导。

比如要编写一个函数 F(G,H) , 接受两个一元函数参数 G(x) , H(x) ,返回一个函数: R(op) ,R(op) 接受一个二元操作函数 op(x,y),返回一个一元函数 T(x)。即:F(G(x), H(x)) = R(op)(x) = op(G, H)(x) = T(x) : x -> op(G(x), H(x))

看上去挺绕的!那么该怎么写呢?

先理一理: R(op)(x) = G(x) op H(x) = op(G, H)(x) 。由于 R(op) 是接受一个二元操作函数 opFunc, 那么应该有 opFunc -> opFunc(G, H) ; 完成了一半! 注意到,opFunc(G,H) 的结果应当是一个单元函数 T(x) ,opFunc(G,H) = x -> T(x) , T(x) = op(G(x), H(x)) ; 于是最终有 F(G(x), H(x)) = opFunc -> { x -> opFunc(G(x), H(x)) }

public static <T> Function<BiFunction<T,T,T>, Function<T,T>> op(Function<T,T> funcx, Function<T,T> funcy) {
   return opFunc -> { return aT -> opFunc.apply(funcx.apply(aT), funcy.apply(aT)); };
}

只要是赋值给函数接口,一定有 (x1,x2,…,xn) -> F(x1,x2,…,Xn) 形式。 然后无非是这种形式的组合及嵌套。 经过一通脑筋急转弯之后,似乎摸到了一点窍门。化简成 lambda 表达式的形式是(IDE会自动提示):

public static <T> Function<BiFunction<T,T,T>, Function<T,T>> op(Function<T,T> funcx, Function<T,T> funcy) {
   return opFunc -> aT -> opFunc.apply(funcx.apply(aT), funcy.apply(aT));
}

第一种形式更容易理解, 第二种形式比较简洁。显然, -> 符号是右结合优先的。

由此可见,函数式编程可以通过凝练的代码形式将函数能力组合起来,构建强大的抽象表达能力,对于消除重复代码及框架设计有很大的益处。同时,使用函数编程需要经常从“函数及组合的层面”去思考计算,而不是从通常的“求值层面”去思考计算。这无疑对抽象思维能力有更高的要求。

不是每个知识点都要正儿八经地写上一篇文章,多尝试摸索窍门反而是妙法。

如果您觉得不错,请别忘了转发、分享、点赞让更多的人去学习, 您的举手之劳,就是对小乐最好的支持,非常感谢!

如何您想进技术群和大牛们交流,关注公众号在后台回复 “加群”,或者 “学习” 即可

来自:琴水玉

链接:

http://www.cnblogs.com/lovesqcc/p/7107558.html

著作权归作者所有。本文已获得授权。欢迎投稿。

每日英文


Though I fall, I will rise again. Don’t lose hope. You never know what tomorrow will bring. 

就算我失败了,我也会再起。不要失去希望,你永远不知道明天会带给你什么。

乐乐有话说

生活总是让我们遍体鳞伤,但请相信,你今天受的苦,吃的亏,担的责,扛的罪,忍的痛,到最后都会变成光,照亮你的路。

Java函数接口实现函数组合及装饰器模式


推荐阅读







看完本文有收获?请转发分享给更多人
关注「杨守乐」,提升技能

以上就是:Java函数接口实现函数组合及装饰器模式 的全部内容。

本站部分内容来源于互联网和用户投稿,如有侵权请联系我们删除,谢谢。
Email:[email protected]


0 条回复 A 作者 M 管理员
    所有的伟大,都源于一个勇敢的开始!
欢迎您,新朋友,感谢参与互动!欢迎您 {{author}},您在本站有{{commentsCount}}条评论