编程范式

  • 面对对象的编程方式：问题抽象为类，处理类之间的关系
  • 函数式编程范式：函数代表抽象的计算

举例

订单统计订单总额、班级统计总分，统计逻辑相似但由于在不同类中 抽象出的计算模式： 保存计算结果的状态，有初始值

遍历操作

遍历时进行的计算，更新保存计算结果的状态值

lambda表达式:

实质返回的是一个匿名内部类 //配合函数式接口简化使用

  1. public interface Condition {
  2.     boolean evaluate(Map<String, Object> param);
  3.     Condition conditionA = new Condition() {
  4.         @Override
  5.         public boolean evaluate(Map<String, Object> param) {
  6.             return false;
  7.         }
  8.     };
  9.     Condition conditionB = (param) -> {return false;};
  10.     Condition conditionC =  param -> false;
  11. }

范例

集合forEeach()方法的实现

  1. List features = Arrays.asList("Lambdas","Default Method");
  2. features.forEach(n -> System.out.println(n));
  3. features.forEach(StringUtils::isEmpty); //方法引用是Lambda表达式的简写

原理

Iterator接口中的默认方法

  1. default void forEach(Consumer<? super T> action) {
  2.     Objects.requireNonNull(action);
  3.     for (T t : this) {
  4.         action.accept(t);
  5.     }
  6. }

高阶函数

  • 高阶函数以其他函数作为输入，或产生其他函数作为输出
  • 高阶函数使得函数的组合成为可能，更有利于函数的复用
  1. public class HighOrderFunctions {
  2.     private static <T> Predicate<T> notEqual(T t) {
  3.          return (v) -> !Objects.equals(v, t);
  4.     }
  5.     //等价方法
  6.     private static <T> Predicate<T> notEqual1(T t) {
  7.         return new Predicate<T>() {
  8.             @Override
  9.             public boolean test(T v) {
  10.                 return !Objects.equals(v,t);
  11.             }
  12.         };
  13.     }
  14.     public static void main(String[] args) {
  15.         Stream.of(1, 2, 3)
  16.            .filter(notEqual(1))
  17.            .forEach(System.out::println);
  18.     }
  19. }

部分函数

部分函数(partial function)是指仅有部分输入参数被绑定了实际值的函数

  1. public class PartialFunctions {
  2.     private static  <T, U, R> Function<U, R> partialLeft(BiFunction<T, U, R> biFunction, T t) {
  3.         return (u) -> biFunction.apply(t, u);
  4.     }
  5.     private static  <T, U, R> Function<T, R> partialRight(BiFunction<T, U, R> biFunction, U u) {
  6.         return (t) -> biFunction.apply(t, u);
  7.     }
  8.     public static void main(String[] args) {
  9.         BiFunction<Integer, Integer, Integer> biFunction = (v1, v2) -> v1 - v2;
  10.         Function<Integer, Integer> subtractFrom10 = partialLeft(biFunction, 10);
  11.         Function<Integer, Integer> subtractBy10 = partialRight(biFunction, 10);
  12.         System.out.println(subtractFrom10.apply(5)); // 5
  13.         System.out.println(subtractBy10.apply(5));   // -5
  14.     }
  15. }

柯里化

通过柯里化，可以把有多个输入的函数转换成只有一个输入的函数 柯里化是把有多个输入参数的求值过程，转换成多个只包含一个参数的函数的求值过程