函数式编程

  • 使用某种方式操纵其他代码
  • 不用从头开始编写大量代码，而是从易于理解、充分测试及可靠的现有小块开始，最后将它们组合在一起以创建新代码。

函数式编程

  • 通过合并现有代码来生成新功能而不是从头开始编写所有内容，我们可以更快地获得更可靠的代码。
  • OO（object oriented，面向对象）是抽象数据，FP（functional programming，函数式编程）是抽象行为。

如果希望方法在调用时行为不同，该怎么做呢？
只要能将代码传递给方法，我们就可以控制它的行为。

函数式接口:

  • 只有一个方法的接口 ```java interface Strategy { String approach(String msg); }
  1. 以其为模板
  2. ```java
  3.     static String app(String s) {
  4.         return s + "?";
  5.     }
  7.     public static void main(String[] args) {
  8.         Strategy[] strategies = new Strategy[]{
  9.                 new Strategy() {
  10.                     @Override
  11.                     public String approach(String msg) {
  12.                         return "zms";  // 匿名内部类
  13.                     }
  14.                 },
  15.                 msg -> msg + "!", // lambda
  16.                 TriFunctionTest::app  // 方法引用
  17.         };

Lambda表达式

是使用最小可能语法来编写函数定义

方法引用:

方法引用，它以::为特征。::的左边是类或对象的名称， ::的右边是方法的名称，但是没有参数列表。
方法引用组成：类名或对象名，后面跟 ::，然后跟方法名称。

  1. public class TriFunctionTest {
  3.     interface Callable { // [1]
  4.         void call(String s);
  5.     }
  7.     public void func(String s) {
  8.         System.out.println("TriFunctionTest.func");
  9.     }
  11.     public static void funStatic(String s) {
  12.         System.out.println("TriFunctionTest.funStatic");
  13.     }
  15.     public static void main(String[] args) {
  16.         Callable callable1 = new TriFunctionTest()::func;
  17.         Callable callable2 = TriFunctionTest::funStatic;
  18.         callable1.call("zms");
  19.         callable2.call("zms");
  20.         /**
  21.          * TriFunctionTest.func
  22.          * TriFunctionTest.funStatic
  23.          */
  24.     }
  25. }
  1. interface和引用的方法的名字不重要,重要的是返回值和参数是不是匹配
  2. 静态方法引用不需要实例化类对象
  3. 引用非静态方法需要实例化对象

基本特征

  • 参数和函数体被箭头->分隔开: msg -> msg + “!”
  • 当只用一个参数，可以不需要括号 ()
  • 如果没有参数，则必须使用括号 () 表示空参数列表。
  • 对于多个参数，将参数列表放在括号 () 中。
  • 单行的Lambda不使用return
  • 多行的必须使用{}+return

Lambda的例子

  1. public class TriFunctionTest {
  2.     interface ClassA {
  3.         String A(String a);
  4.     }
  6.     interface ClassB {
  7.         String B(String a, Double b);
  8.     }
  10.     public static void main(String[] args) {
  11.         ClassA classA = str -> str + "!";
  12.         System.out.println(classA.A("zms"));
  14.         ClassB classB = (str, b) -> str + b + "?";
  15.         System.out.println(classB.B("zms", 88.0));
  16.     }
  17. }
  20. zms!
  21. zms88.0?

Lambda递归

递归方法必须是成员变量或静态变量，否则会出现编译时错误。
1. 静态变量的情况

  1. public class TriFunctionTest {
  3.     private static Fab f;
  5.     interface Fab {
  6.         int fab(int n);
  7.     }
  9.     public static void main(String[] args) {
  10.         f = n -> n == 0 ? 1 : n == 1 ? 1 : f.fab(n - 1) + f.fab(n - 2);
  11.         for (int i = 0; i < 10; i++) {
  12.             System.out.println(f.fab(i));
  13.         }
  14.     }
  15. }

  1. 成员变量

    1. public class TriFunctionTest {
    3.  Fab f;
    5.  interface Fab {
    6.      int fab(int n);
    7.  }
    9.  public static void main(String[] args) {
    10.      TriFunctionTest triFunctionTest = new TriFunctionTest();
    11.      triFunctionTest.f = n ->
    12.              n == 0 ? 1 :
    13.                      n == 1 ? 1 :
    14.                              triFunctionTest.f.fab(n - 1) + triFunctionTest.f.fab(n - 2);
    16.      for (int i = 0; i < 10; i++) {
    17.          System.out.println(triFunctionTest.f.fab(i));
    18.      }
    19.  }
    20. }

    Runnable接口

    接口的方法不带参数以及返回值
    public abstract void run();

    1.  public static void main(String[] args) {
    2.      Runnable runnable = () -> {
    3.          System.out.println("TriFunctionTest.main");
    4.      };
    5.      runnable.run();
    6.  }

    例子2:

    1.  public static void main(String[] args) {
    2.      new Thread(() -> System.out.println("TriFunctionTest.main")).start();
    3.      new Thread(() -> {
    4.          System.out.println("zms");
    5.          System.out.println("vms");
    6.      }).start();
    7.      // 也可以使用方法引用作为作为参数传入Thread
    8.  }

    未绑定的方法引用

    指没有关联对象的非静态方法.
    使用未绑定的引用时，我们必须先提供对象：

    1. public class TriFunctionTest {
    2.  static class X {
    3.      String f() {
    4.          return "X::F";
    5.      }
    6.  }
    8.  interface MakeString {
    9.      String make();
    10.  }
    12.  interface TransformX {
    13.      String transform(X x); 
    14.  }
    16.  public static void main(String[] args) {
    17.      /*
    18.      MakeString makeString = X::f;  // 不能直接赋值,因为f()不是静态方法
    19.       */
    20.      TransformX transformX = X::f;
    21.      X x = new X();
    22.      System.out.println(transformX.transform(x));
    23.  }
    24. }

    引用f()时候需要使用this对象,因为f()不是静态的方法,必须有一个对象对他进行调用.
    拿到未绑定的方法引用，并且调用它的transform()方法，将一个X类的对象传递给它，最后使得 x.f() 以某种方式被调用。Java知道它必须拿第一个参数，该参数实际就是this 对象，然后对此调用方法。

  • 如果你的方法有更多个参数，就以第一个参数接受this的模式来处理。

    1. public class TriFunctionTest {
    2.   static class X {
    3.       String f(int a) {
    4.           return "X::F" + a;
    5.       }
    6.   }
    8.   interface MakeString {
    9.       String make();
    10.   }
    12.   interface TransformX {
    13.       String transform(X x, int a);// 自动将a传给了x对象
    14.   }
    16.   public static void main(String[] args) {
    17.       /*
    18.       MakeString makeString = X::f;  // 不能直接赋值,因为f()不是静态方法
    19.        */
    20.       TransformX transformX = X::f;
    21.       X x = new X();
    22.       System.out.println(transformX.transform(x,1));  // X::F1
    23.   }
    24. }

    构造函数引用

    构造函数只有一个相同名称：:: new,根据不同的参数确定具体的构造函数! ```java class Dog { String name; int age = -1; // For “unknown” Dog() { name = “stray”; } Dog(String nm) { name = nm; } Dog(String nm, int yrs) { name = nm; age = yrs; } }

public class TriFunctionTest { interface MakeNoArgs { Dog make(); }

  1. interface Make1Arg {
  2.     Dog make(String nm);
  3. }
  5. interface Make2Args {
  6.     Dog make(String nm, int age);
  7. }
  9. public static void main(String[] args) {
  10.     MakeNoArgs noArgs = Dog::new;
  11.     Make1Arg make1Arg = Dog::new;
  12.     Make2Args make2Args = Dog::new;
  14.     System.out.println(noArgs.make());
  15.     System.out.println(make1Arg.make("zms"));
  16.     System.out.println(make2Args.make("zms", 11));

// fp.Dog@6d03e736 // fp.Dog@568db2f2 // fp.Dog@378bf509 } }

  2. <a name="ZAz7O"></a>
  3. ## 函数式接口
  5. - 方法引用和 Lambda 表达式都必须被赋值，同时赋值需要类型信息才能使编译器保证类型的正确性。
  6. - Lambda 表达式包含 类型推导 （编译器会自动推导出类型信息，避免了程序员显式地声明）。编译器必须能够以某种方式推导出 x 的类型。
  7. - 当 Lambda 表达式被赋值时，编译器必须确定 x 和 y 的确切类型以生成正确的代码。

(x, y) -> x + y

  2. - 使用 `@`**`FunctionalInterface` **注解强制执行此“函数式方法”模式：
  3.    - 每个接口只包含**一个抽象方法**，称为 _函数式方法_ 。
  4. ```java
  5. // functional/FunctionalAnnotation.java
  7. @FunctionalInterface
  8. interface Functional {
  9.   String goodbye(String arg);
  10. }
  12. interface FunctionalNoAnn {
  13.   String goodbye(String arg);
  14. }
  16. /*
  17. @FunctionalInterface
  18. interface NotFunctional {
  19.   String goodbye(String arg);
  20.   String hello(String arg);
  21. }
  22. 产生错误信息:
  23. 函数式方法必须只有一个抽象函数
  24. */
  26. public class FunctionalAnnotation {
  27.   public String goodbye(String arg) {
  28.     return "Goodbye, " + arg;
  29.   }
  30.   public static void main(String[] args) {
  31.     FunctionalAnnotation fa =
  32.       new FunctionalAnnotation();
  33.     Functional f = fa::goodbye;
  34.     FunctionalNoAnn fna = fa::goodbye;
  35.     // Functional fac = fa; //错误!FunctionalAnnotation 并没有显式地去实现 Functional 接口。
  36.     Functional fl = a -> "Goodbye, " + a;
  37.     FunctionalNoAnn fnal = a -> "Goodbye, " + a;
  38.   }
  39. }

自带的函数接口

命名规则

  1. 处理的是对象而不是基本类型
    1. Function
    2. Consumer
    3. Predicate
  2. 接受的参数是基本类型,由名称的第一部分进行标识
    1. LongConsumer
    2. DoubleFunction
    3. IntPredicate
    4. 返回基本类型的Supplier(无参数返回任意类型)除外
  3. 如果返回值是基本类型,用To表示
    1. ToLongFunction<T>
    2. IntToLongFunction
  4. 返回类型和参数类型相同Operator
    1. UnaryOPerator单个参数
    2. BinaryOperator两个参数
  5. 接受参数并返回boolean使用谓词Predicate
  6. 接受的两个参数类型不同,名称中有一个Bi

系统接口

特征 函数式方法名 示例
无参数；
无返回值		 Runnable
(java.lang)
run()		 Runnable
无参数；
返回类型任意		 Supplier
get()
getAs类型()		 Supplier<T>
BooleanSupplier
IntSupplier
LongSupplier
DoubleSupplier
无参数；
返回类型任意		 Callable
(java.util.concurrent)
call()		 Callable<V>
1 参数；
无返回值		 Consumer
accept()		 Consumer<T>
IntConsumer
LongConsumer
DoubleConsumer
2 参数 Consumer BiConsumer
accept()		 BiConsumer<T,U>
2 参数 Consumer；
第一个参数是 引用；
第二个参数是 基本类型		 Obj类型Consumer
accept()		 ObjIntConsumer<T>
ObjLongConsumer<T>
ObjDoubleConsumer<T>
1 参数；
返回类型不同		 Function
apply()
To类型 和 类型To类型
applyAs类型()		 Function<T,R>
IntFunction<R>
LongFunction<R>
DoubleFunction<R>
ToIntFunction<T>
ToLongFunction<T>
ToDoubleFunction<T>
IntToLongFunction
IntToDoubleFunction
LongToIntFunction
LongToDoubleFunction
DoubleToIntFunction
DoubleToLongFunction
1 参数；
返回类型相同		 UnaryOperator
apply()		 UnaryOperator<T>
IntUnaryOperator
LongUnaryOperator
DoubleUnaryOperator
2 参数，类型相同；
返回类型相同		 BinaryOperator
apply()		 BinaryOperator<T>
IntBinaryOperator
LongBinaryOperator
DoubleBinaryOperator
2 参数，类型相同;
返回整型		 Comparator
(java.util)
compare()		 Comparator<T>
2 参数；
返回布尔型		 Predicate
test()		 Predicate<T>
BiPredicate<T,U>
IntPredicate
LongPredicate
DoublePredicate
参数基本类型；
返回基本类型		 类型To类型Function
applyAs类型()		 IntToLongFunction
IntToDoubleFunction
LongToIntFunction
LongToDoubleFunction
DoubleToIntFunction
DoubleToLongFunction
2 参数；
类型不同		 Bi操作
(不同方法名)		 BiFunction<T,U,R>
BiConsumer<T,U>
BiPredicate<T,U>
ToIntBiFunction<T,U>
ToLongBiFunction<T,U>
ToDoubleBiFunction<T>

例子:
所有不同的Function变体实例

  1. // functional/FunctionVariants.java
  3. import java.util.function.*;
  5. class Foo {}
  7. class Bar {
  8.   Foo f;
  9.   Bar(Foo f) { this.f = f; }
  10. }
  12. class IBaz {
  13.   int i;
  14.   IBaz(int i) {
  15.     this.i = i;
  16.   }
  17. }
  19. class LBaz {
  20.   long l;
  21.   LBaz(long l) {
  22.     this.l = l;
  23.   }
  24. }
  26. class DBaz {
  27.   double d;
  28.   DBaz(double d) {
  29.     this.d = d;
  30.   }
  31. }
  33. public class FunctionVariants {
  34.   static Function<Foo,Bar> f1 = f -> new Bar(f);
  35.   static IntFunction<IBaz> f2 = i -> new IBaz(i);
  36.   static LongFunction<LBaz> f3 = l -> new LBaz(l);
  37.   static DoubleFunction<DBaz> f4 = d -> new DBaz(d);
  38.   static ToIntFunction<IBaz> f5 = ib -> ib.i;
  39.   static ToLongFunction<LBaz> f6 = lb -> lb.l;
  40.   static ToDoubleFunction<DBaz> f7 = db -> db.d;
  41.   static IntToLongFunction f8 = i -> i;
  42.   static IntToDoubleFunction f9 = i -> i;
  43.   static LongToIntFunction f10 = l -> (int)l;
  44.   static LongToDoubleFunction f11 = l -> l;
  45.   static DoubleToIntFunction f12 = d -> (int)d;
  46.   static DoubleToLongFunction f13 = d -> (long)d;
  48.   public static void main(String[] args) {
  49.     Bar b = f1.apply(new Foo());
  50.     IBaz ib = f2.apply(11);
  51.     LBaz lb = f3.apply(11);
  52.     DBaz db = f4.apply(11);
  53.     int i = f5.applyAsInt(ib);
  54.     long l = f6.applyAsLong(lb);
  55.     double d = f7.applyAsDouble(db);
  56.     l = f8.applyAsLong(12);
  57.     d = f9.applyAsDouble(12);
  58.     i = f10.applyAsInt(12);
  59.     d = f11.applyAsDouble(12);
  60.     i = f12.applyAsInt(13.0);
  61.     l = f13.applyAsLong(13.0);
  62.   }
  63. }

这些 Lambda 表达式尝试生成适合函数签名的最简代码。 在某些情况下有必要进行强制类型转换，否则编译器会报截断错误。

使用函数接口时，名称无关紧要——只要参数类型和返回类型相同。 Java 会将你的方法映射到接口方法。 要调用方法，可以调用接口的函数式方法名,例Runnable的run()，而不是你的方法名。

  1. // functional/ClassFunctionals.java
  3. import java.util.*;
  4. import java.util.function.*;
  6. class AA {}
  7. class BB {}
  8. class CC {}
  10. public class ClassFunctionals {
  11.   static AA f1() { return new AA(); }
  12.   static int f2(AA aa1, AA aa2) { return 1; }
  13.   static void f3(AA aa) {}
  14.   static void f4(AA aa, BB bb) {}
  15.   static CC f5(AA aa) { return new CC(); }
  16.   static CC f6(AA aa, BB bb) { return new CC(); }
  17.   static boolean f7(AA aa) { return true; }
  18.   static boolean f8(AA aa, BB bb) { return true; }
  19.   static AA f9(AA aa) { return new AA(); }
  20.   static AA f10(AA aa1, AA aa2) { return new AA(); }
  21.   public static void main(String[] args) {
  22.     Supplier<AA> s = ClassFunctionals::f1;
  23.     s.get();
  24.     Comparator<AA> c = ClassFunctionals::f2;
  25.     c.compare(new AA(), new AA());
  26.     Consumer<AA> cons = ClassFunctionals::f3;
  27.     cons.accept(new AA());
  28.     BiConsumer<AA,BB> bicons = ClassFunctionals::f4;
  29.     bicons.accept(new AA(), new BB());
  30.     Function<AA,CC> f = ClassFunctionals::f5;
  31.     CC cc = f.apply(new AA());
  32.     BiFunction<AA,BB,CC> bif = ClassFunctionals::f6;
  33.     cc = bif.apply(new AA(), new BB());
  34.     Predicate<AA> p = ClassFunctionals::f7;
  35.     boolean result = p.test(new AA());
  36.     BiPredicate<AA,BB> bip = ClassFunctionals::f8;
  37.     result = bip.test(new AA(), new BB());
  38.     UnaryOperator<AA> uo = ClassFunctionals::f9;
  39.     AA aa = uo.apply(new AA());
  40.     BinaryOperator<AA> bo = ClassFunctionals::f10;
  41.     aa = bo.apply(new AA(), new AA());
  42.   }
  43. }

每个方法名称都是随意的（如 f1()，f2()等）。正如你刚才看到的，一旦将方法引用赋值给函数接口，我们就可以调用与该接口关联的函数方法。 在此示例中为 get()、compare()、accept()、apply() 和 test()。

自定义接口

接口是有限的。比如有 BiFunction，但也仅此而已。 如果需要三参数函数的接口怎么办？ 其实这些接口非常简单，很容易查看 Java 库源代码并自行创建。

  1. @FunctionalInterface
  2. public interface TriFunction<T, U, V, R> {
  3.     R apply(T t, U u, V v);
  4. }
  1. // functional/TriFunctionTest.java
  3. public class TriFunctionTest {
  4.   static int f(int i, long l, double d) { return 99; }
  5.   public static void main(String[] args) {
  6.     TriFunction<Integer, Long, Double, Integer> tf =
  7.       TriFunctionTest::f;  // 使用引用进行赋值
  8.     tf = (i, l, d) -> 12;  // 使用lambda进行赋值
  9.   }
  10. }

高阶函数

  • 消费或者产生函数的函数

产生函数

  1. public class ProduceFunction {
  2.     interface FuncSS extends Function<String, String> {
  3.     }
  5.     static FuncSS produce() {
  6.         //返回一个FuncSS,所以下面的s可以知道是String
  7.         return s -> s.toLowerCase();
  8.     }
  10.     public static void main(String[] args) {
  11.         FuncSS funcSS = produce();
  12.         System.out.println(funcSS.apply("VMS"));
  13.     }
  14. }
  • produce() 是高阶函数。
    • 使用继承，可以轻松地为专用接口创建别名
    • 使用 Lambda 表达式，可以轻松地在方法中创建和返回一个函数。

    • 消费函数

      要消费函数,需要在参数列表正确的描述函数类型
      ** ```java class One { }

class Two { }

public class ProduceFunction { static Two consume(Function oneTwoFunction) { return oneTwoFunction.apply(new One()); }

  1. public static void main(String[] args) {
  2.     System.out.println(consume(one -> new Two()));
  3. }

}

  2. 基于消费函数生成新函数:
  3. ```java
  4. class I {
  5.     @Override
  6.     public String toString() {
  7.         return "I";
  8.     }
  9. }
  11. class O {
  12.     @Override
  13.     public String toString() {
  14.         return "O";
  15.     }
  16. }
  18. public class ProduceFunction {
  19.     static Function<I, O> transform(Function<I, O> in) {
  20.         return in.andThen(o -> {
  21.             System.out.println(o);
  22.             return o;
  23.         });
  24.     }
  26.     public static void main(String[] args) {
  27.         Function<I, O> f = transform(i -> {
  28.             System.out.println(i);
  29.             return new O();
  30.         });
  31.         O o = f.apply(new I());
  32.     }
  34. }

使用到了 Function 接口中名为 andThen() 的默认方法，该方法专门用于操作函数。
在调用 in 函数之后调用 andThen().
要附加一个 andThen() 函数，我们只需将该函数作为参数传递。
transform() 产生的是一个新函数，它将 in 的动作与 andThen() 参数的动作结合起来。

闭包

如果一个lambda使用了作用域之外的变量,返回该函数会发生什么?


Lambda 可以没有限制地引用 实例变量和静态变量。但 局部变量必须显式声明为final，或事实上是final 。

引用外部变量

  1. // functional/Closure1.java
  3. import java.util.function.*;
  5. public class Closure1 {
  6.   int i;  // 对于函数来说是一个外部变量
  7.   IntSupplier makeFun(int x) {
  8.     return () -> x + i++;
  9.   }
  10. }

如果你对同一个对象多次调用 makeFun() ，你最终会得到多个函数，它们共享 i 的存储空间：

  1. class Closure1 {
  2.     int i;
  4.     IntSupplier makeFun(int x) {
  5.         return () -> x + i++;
  6.     }
  7. }
  9. public class ProduceFunction {
  10.     public static void main(String[] args) {
  11.         Closure1 closure1 = new Closure1();
  12.         IntSupplier f1 = closure1.makeFun(0);
  13.         IntSupplier f2 = closure1.makeFun(0);
  14.         IntSupplier f3 = closure1.makeFun(0);
  15.         System.out.println(f1.getAsInt());
  16.         System.out.println(f2.getAsInt());
  17.         System.out.println(f3.getAsInt());
  18.         /*
  19.             0
  20.             1
  21.             2
  22.          */
  23.     }
  24. }

每次调用 getAsInt() 都会增加 i，表明存储是共享的。

引用局部变量

  1. class Closure1 {
  2.     IntSupplier makeFun(int x) {
  3.         int i  = 0;
  4.         return () -> x + i;
  5.     }
  6. }

makeFun() 返回的 IntSupplier “关住了” i 和 x，因此即使makeFun()已执行完毕，当你调用返回的函数时i 和 x仍然有效，而不是像正常情况下那样在 makeFun() 执行后 i 和x就消失了。

  • 编译不通过

image.png
x 和 i 的操作都犯了同样的错误：
被 Lambda 表达式引用的局部变量必须是 final 或者是等同 final (变量值没被改变过而实际有了 final 同等的效果)效果的。

  • 编译不通过

image.png
改变一下:
image.png

  • 但与对象类型,只要对应的内存地址不改变就可以 ```java // functional/Closure8.java

import java.util.; import java.util.function.;

public class Closure8 { Supplier> makeFun() { final List ai = new ArrayList<>(); ai.add(1); return () -> ai; } public static void main(String[] args) { Closure8 c7 = new Closure8(); List l1 = c7.makeFun().get(), l2 = c7.makeFun().get(); System.out.println(l1); System.out.println(l2); l1.add(42); l2.add(96); System.out.println(l1); System.out.println(l2); } }

[1] [1] [1, 42] [1, 96]

下面是错误的情况 public class Closure9 { Supplier> makeFun() { List ai = new ArrayList<>(); ai = new ArrayList<>(); // 错误!违反对象的final!!!!!! return () -> ai; } }

  2. - 内部类的情况
  4. ![image.png](https://cdn.nlark.com/yuque/0/2021/png/8429887/1611152381753-ed18c063-e06b-43fa-98f3-f7ae78a734c3.png#align=left&display=inline&height=317&margin=%5Bobject%20Object%5D&name=image.png&originHeight=317&originWidth=449&size=20380&status=done&style=none&width=449)<br />也是不可以的!
  6. <a name="dXfRr"></a>
  7. ## 函数组合
  9. - 多个函数组合成新的函数
  10. | 组合方法 | 支持接口 |
  11. | --- | --- |
  12. | `andThen(argument)`<br />执行原操作,再执行参数操作 | **Function<br />BiFunction<br />Consumer<br />BiConsumer<br />IntConsumer<br />LongConsumer<br />DoubleConsumer<br />UnaryOperator<br />IntUnaryOperator<br />LongUnaryOperator<br />DoubleUnaryOperator<br />BinaryOperator** |
  13. | `compose(argument)`<br />执行参数操作,再执行原操作 | **Function<br />UnaryOperator<br />IntUnaryOperator<br />LongUnaryOperator<br />DoubleUnaryOperator** |
  14. | `and(argument)`<br />原谓词(Predicate)和参数谓词的短路**逻辑与** | **Predicate<br />BiPredicate<br />IntPredicate<br />LongPredicate<br />DoublePredicate** |
  15. | `or(argument)`<br />原谓词和参数谓词的短路**逻辑或** | **Predicate<br />BiPredicate<br />IntPredicate<br />LongPredicate<br />DoublePredicate** |
  16. | `negate()`<br />该谓词的**逻辑非**<br />**<br /> p1.negate() 表示对P1的结果取非 | **Predicate<br />BiPredicate<br />IntPredicate<br />LongPredicate<br />DoublePredicate** |
  18. - Function版本
  19. ```java
  20. public class ProduceFunction {
  21.     static Function<String, String>
  22.             f1 = s -> {
  23.                 System.out.println(s);
  24.                 return s.replace('A', '_');
  25.             },
  26.             f2 = s -> s.substring(3),
  27.             f3 = s -> s.toLowerCase(),
  28.             f4 = f1.compose(f2).andThen(f3);  //f2->f1->f3
  30.     public static void main(String[] args) {
  31.         System.out.println(f4.apply("GO AFTER ALL AMBULANCES"));
  32.     }
  33.     /*
  34. AFTER ALL AMBULANCES
  35. _fter _ll _mbul_nces    
  36.      */
  37. }

当 f1 获得字符串时，它已经被f2 剥离了前三个字符。这是因为 compose（f2） 表示 f2 的调用发生在 f1 之前。

  • 谓词Predicate版本 ```java // functional/PredicateComposition.java

import java.util.function.; import java.util.stream.;

public class PredicateComposition { static Predicate p1 = s -> s.contains(“bar”), p2 = s -> s.length() < 5, p3 = s -> s.contains(“foo”), p4 = p1.negate().and(p2).or(p3); public static void main(String[] args) { Stream.of(“bar”, “foobar”, “foobaz”, “fongopuckey”) .filter(p4) .forEach(System.out::println); } }

=== foobar foobaz

  1. `p4` 获取到了所有谓词(`Predicate`)并组合成一个更复杂的谓词。
  3. - 如果字符串中不包含 `bar` 且长度小于 5，或者它包含 `foo` ，则结果为 `true`。
  5. <a name="zrnXL"></a>
  6. ## 柯里化
  8. 将一个多参数的函数，转换为一系列单参数函数。
  10. ```java
  11. // functional/CurryingAndPartials.java
  13. import java.util.function.*;
  15. public class CurryingAndPartials {
  16.    // 未柯里化:
  17.    static String uncurried(String a, String b) {
  18.       return a + b;
  19.    }
  20.    public static void main(String[] args) {
  21.       // 柯里化的函数:
  22.       Function<String, Function<String, String>> sum =
  23.          a -> b -> a + b; // [1]
  25.       System.out.println(uncurried("Hi ", "Ho"));
  27.       Function<String, String>
  28.         hi = sum.apply("Hi "); // [2]
  29.       System.out.println(hi.apply("Ho"));
  31.       // 部分应用:
  32.       Function<String, String> sumHi =
  33.         sum.apply("Hup ");
  34.       System.out.println(sumHi.apply("Ho"));
  35.       System.out.println(sumHi.apply("Hey"));
  36.    }
  37. }
  40. ===
  41. Hi Ho
  42. Hi Ho
  43. Hup Ho
  44. Hup Hey

[1] 这一连串的箭头很巧妙。注意，在函数接口声明中，第二个参数是另一个函数。
[2] 柯里化的目的是能够通过提供单个参数来创建一个新函数，所以现在有了一个“带参函数”和剩下的 “自由函数”（free argument） 。
每一级的箭头级联（Arrow-cascading），你都会在类型声明周围包裹另一个 Function 。
三级

  1. // functional/Curry3Args.java
  3. import java.util.function.*;
  5. public class Curry3Args {
  6.    public static void main(String[] args) {
  7.       Function<String,
  8.         Function<String,
  9.           Function<String, String>>> sum =
  10.             a -> b -> c -> a + b + c;
  11.       Function<String,
  12.         Function<String, String>> hi =
  13.           sum.apply("Hi ");
  14.       Function<String, String> ho =
  15.         hi.apply("Ho ");
  16.       System.out.println(ho.apply("Hup"));  ///Hi Ho Hup
  17.    }
  18. }

处理基本类型和装箱时，请使用适当的函数式接口：

  1. // functional/CurriedIntAdd.java
  3. import java.util.function.*;
  5. public class CurriedIntAdd {
  6.   public static void main(String[] args) {
  7.     IntFunction<IntUnaryOperator>
  8.       curriedIntAdd = a -> b -> a + b;
  9.     IntUnaryOperator add4 = curriedIntAdd.apply(4);
  10.     System.out.println(add4.applyAsInt(5)); ///9
  11.       }
  12. }

流式编程