java8--函数式编程

其实在java8就已经有java的函数式编程写法，只是难度较大，大家都习惯了对象式用法，但在其它语言中都有函数式的用法，如js,scala，函数式其实是抽象到极致的思想。

什么是函数式编程

函数式编程并不是Java新提出的概念，其与指令编程相比，强调函数的计算比指令的计算更重要；与过程化编程相比，其中函数的计算可以随时调用。

当然，大家应该都知道面向对象的特性（抽象、封装、继承、多态）。其实在Java8出现之前，我们关注的往往是某一类对象应该具有什么样的属性，当然这也是面向对象的核心--对数据进行抽象。但是java8出现以后，这一点开始出现变化，似乎在某种场景下，更加关注某一类共有的行为（这似乎与之前的接口有些类似），这也就是java8提出函数式编程的目的。如图1-1所示，展示了面向对象编程到面向行为编程的变化。

fun.png

函数接口

接口	参数	返回类型	描述
Predicate	T	boolean	用来比较操作
Consumer	T	void	没有返回值的函数
Function	T	R	有返回值的函数
Supplier	None	T	工厂方法-返回一个对象
UnaryOperator	T	T	入参和出参都是相同对象的函数
BinaryOperator	(T,T)	T	求两个对象的操作结果

java8 函数式编程的入口,每个函数接口都带有 @FunctionalInterface 注释，有且仅有一个未实现的方法，表示接收 Lambda 表达式，它们存在的意义在于将代码块作为数据打包起来。
这几个函数接口，完全可以把它们看成普通的接口，不过他们有且仅有一个抽象方法（因为要接收 Lambda 表达式）。
@FunctionalInterface 该注释会强制 javac 检查一个接口是否符合函数接口的标准。 如果该注释添加给一个枚举类型、 类或另一个注释， 或者接口包含不止一个抽象方法， javac 就会报错。

Lambda 表达式

Lambda 表达式，有时候也称为匿名函数或箭头函数，几乎在当前的各种主流的编程语言中都有它的身影。Java8 中引入 Lambda 表达式，使原本需要用匿名类实现接口来传递行为，现在通过 Lambda 可以更直观的表达。

• Lambda 表达式，也可称为闭包。闭包就是一个定义在函数内部的函数，闭包使得变量即使脱离了该函数的作用域范围也依然能被访问到。
• Lambda 表达式的本质只是一个”语法糖”，由编译器推断并帮你转换包装为常规的代码,因此你可以使用更少的代码来实现同样的功能。
• Lambda 表达式是一个匿名函数，即没有函数名的函数。有些函数如果只是临时一用，而且它的业务逻辑也很简单时，就没必要非给它取个名字不可。
• Lambda 允许把函数作为一个方法的参数（函数作为参数传递进方法中）.

Lambda 表达式语法如下：形参列表=>函数体（函数体多于一条语句的可用大括号括起）。在Java里就是() -> {}：

(parameters) -> expression
(parameters) ->{ statements; }

Lambda表达式的重要特征：

• Lambda 表达式主要用来定义行内执行的方法类型接口，例如，一个简单方法接口。
• Lambda表达式是通过函数式接口（必须有且仅有一个抽象方法声明）识别的
• 可选类型声明：不需要声明参数类型，编译器可以统一识别参数值。
• 可选的参数圆括号：一个参数无需定义圆括号，但多个参数需要定义圆括号。
• 可选的大括号：如果主体包含了一个语句，就不需要使用大括号。
• 可选的返回关键字：如果主体只有一个表达式返回值，则编译器会自动返回值，大括号需要指定表达式返回一个值。

Lambda表达式中的变量作用域：

• 访问权限与匿名对象的方式非常类似。只能够访问局部对应的外部区域的局部final变量，以及成员变量和静态变量。
• 在Lambda表达式中能访问域外的局部非final变量、但不能修改Lambda域外的局部非final变量。因为在Lambda表达式中，Lambda域外的局部非final变量会在编译的时候，会被隐式地当做final变量来处理。
• Lambda表达式内部无法访问接口默认（default）方法.

例子：使用Java 8之前的方法来实现对一个string列表进行排序：

List names = Arrays.asList("peter", "anna", "mike", "xenia");
Collections.sort(names, new Comparator() {
    @Override
    public int compare(String a, String b) {
        return b.compareTo(a);
    }
});

Java 8 Lambda 表达式：

Collections.sort(names, (String a, String b) -> {
    return b.compareTo(a);
});
// 只有一条逻辑语句，可以省略大括号
Collections.sort(names, (String a, String b) -> b.compareTo(a));
// 可以省略入参类型
Collections.sort(names, (a, b) -> b.compareTo(a));

FunctionalInterface

Java8的新引入，包含函数式的设计，接口都有@FunctionalInterface的注解。
如声明一个接口

@FunctionalInterface
public interface fun{}
这会编译错，编译器会告诉你*no target method*。而如果加一个方法：
@FunctionalInterface
public interface fun{
    void run();
}
这就OK了，一个函数式接口声明好了。再加一个呢？
@FunctionalInterface
public interface fun{
    void run();
    void test();
}
不ok，明确说了只有一个抽象方法嘛。但是如果换一种函数签名：
@FunctionalInterface
public interface fun{
    Object equals(Object o);
    void test();
}
这就OK了。一个抽象方法，一个Object的public方法，相安无事。Object还有其他方法，clone方法试试会怎么样？
@FunctionalInterface
public interface fun{
    Object clone();
    void test();
}
这又不行了，因为前面明确说了，要是Object的public方法，而clone是protected的。

小结：函数式接口，有且仅有一个抽象方法，Object的public方法除外。

因为Java本身支持多接口实现，你定义一个Class可以implements多个interface。所以这个限制也没什么影响，如果想约定一个函数式接口来统一，也可以做一些默认的实现来达到一个接口多个抽象方法的目的，比如下面这种做法：

一个普通接口NonFunc：

public interface NonFunc {
    void foo();
    void voo();
}
函数式接口Func：
public interface Func extends NonFunc {
    default void foo();
    default void voo();
    void run();
}
实现的测试类：
Public class FunTest implements Func {
  public static void main(String... args) {
    Func func = new FunTest();
    func.run();
    func.foo();
    func.voo();
  }
  @Override
  public void run() {
    System.out.println("run");
  }
  @Override
  public void foo() {
    System.out.println("foo");
  }
  @Override
  public void voo() {
    System.out.println("voo");
  }
}
函数式接口的一大特性就是可以被lambda表达式和函数引用表达式代替。
public class FunTest {
  public static void main(String... args) {
    FunTest t = new FunTest();
    //lambda
    t.test(10, ()->System.out.println("xxxxx"))
    //method reference
    t.test(100, t::customedFunc);
  }
  public void customedFunc(){
    System.out.println("a customed method reference");
  }
  public void test(int x, Func func) {
    System.out.println(x);
    func.run();
  }
}
上面例子列举了一个lambda模式和一个方法引用模式，这样就可以利用函数式编程强大的能力，将方法作为参数了。
下面再加一例
public class Main {
    public static void main(String[] args) {
        Action action = System.out :: println;
        action.execute("Hello World!");
        test(System.out :: println, "Hello World!");
    }
    static void test(Action action, String str) {
        action.execute(str);
    }
}
@FunctionalInterface
interface Action {
    public void execute(T t);
}

Function

关于Function接口，其接口声明是一个函数式接口，其抽象表达函数为

@FunctionalInterface
public interface Function{
  R apply(T t);
  ...
}

函数意为将参数T传递给一个函数，返回R。即R=Function(T)

其默认实现了3个default方法，分别是compose、andThen和identity，对应的函数表达为：compose对应V=Function(ParamFunction(T))，体现嵌套关系；andThen对应V=ParamFunction(Function(T))，转换了嵌套的顺序；还有identity对应了一个传递自身的函数调用对应Function(T)=T。从这里看出来，compose和andThen对于两个函数f和g来说，f.compose(g)等价于g.andThen(f)。看个例子：

public static void main(String... args){
        Function incr1 = x->x*2;
        Function multiply = x->x*2;
        int x=2;
        System.out.println("f(x)=x+1,when x="+x+", f(x)="+incr1.apply(x));
        System.out.println("f(x)=x+1,g(x)=2x, when x="+x+",f(g(x))="+incr1.compose(multiply).apply(x));
        System.out.println("f(x)=x+1,g(x)=2x, when x="+x+",g(f(x))="+incr1.andThen(multiply).apply(x));
        System.out.println("compose vs andThen: f(g(x))="+incr1.compose(multiply).apply(x)+","+multiply.andThen(incr1).apply(x));
    }

高阶函数

只是普通的lambda表达式，其能力有限。我们会希望引入更强大的函数能力——高阶函数，可以定义任意同类计算的函数。

比如这个函数定义，参数是z，返回值是一个Function，这个Function本身又接受另一个参数y，返回z+y。于是我们可以根据这个函数，定义任意加法函数：

//high order function
Function> makeAdder = z->y->z+y;
x=2;
//define add1
Function add1 = makeAdder.apply(1);
System.out.println("f(x)=x+1,when x="+x+",f(x)="+add1.apply(x));
//define add5
Function add5 = makeAdder.apply(5);
System.out.println("f(x)=x+5, when x="+x+", f(x)="+add5.apply(x));

由于高阶函数接受一个函数作为参数，结果返回另一个函数，所以是典型的函数到函数的映射。
BiFunction提供了二元函数的一个接口声明，举例来说：

//binary fun
BiFunction multiply = (a,b)->a*b;
System.out.println("f(z)=x*y, when x=3,y=5 when f(z)="+multiply,apply(3,5));

其输出结果将是：f(z)=x*y, when x=3,y=5, then f(z)=15。
二元函数没有compose能力，只是默认实现了andThen。

有了一元和二元函数，那么可以通过组合扩展出更多的函数可能。

Function接口相关的接口包括：

• BiFunction ：R apply(T t, U u);接受两个参数，返回一个值，代表一个二元函数；
• DoubleFunction ：R apply(double value);只处理double类型的一元函数；
• IntFunction ：R apply(int value);只处理int参数的一元函数；
• LongFunction ：R apply(long value);只处理long参数的一元函数；
• ToDoubleFunction：double applyAsDouble(T value);返回double的一元函数；
• ToDoubleBiFunction：double applyAsDouble(T t, U u);返回double的二元函数；
• ToIntFunction：int applyAsInt(T value);返回int的一元函数；
• ToIntBiFunction：int applyAsInt(T t, U u);返回int的二元函数；
• ToLongFunction：long applyAsLong(T value);返回long的一元函数；
• ToLongBiFunction：long applyAsLong(T t, U u);返回long的二元函数；
• DoubleToIntFunction：int applyAsInt(double value);接受double返回int的一元函数；
• DoubleToLongFunction：long applyAsLong(double value);接受double返回long的一元函数；
• IntToDoubleFunction：double applyAsDouble(int value);接受int返回double的一元函数；
• IntToLongFunction：long applyAsLong(int value);接受int返回long的一元函数；
• LongToDoubleFunction：double applyAsDouble(long value);接受long返回double的一元函数；
• LongToIntFunction：int applyAsInt(long value);接受long返回int的一元函数；

Operator

Operator其实就是Function，函数有时候也叫作算子。算子在Java8中接口描述更像是函数的补充，和上面的很多类型映射型函数类似。
算子Operator包括：UnaryOperator和BinaryOperator。分别对应单元算子和二元算子。
算子的接口声明如下：

@FunctionalInterface
public interface UnaryOperator extends Function {
  static  UnaryOperator identity(){
    return t->t;
  }
}

二元算子的声明：
算子就是一个针对同类型输入输出的一个映射。在此接口下，只需声明一个泛型参数T即可。对应上面的例子：

public class TestOperator {
  public static void main(String... args) {
    UnaryOperator add = x->x+1;
    System.out.println(add.apply(1))
    
    BinaryOperator addxy = (x,y)->x+y;
    System.out.println(addxy.apply(3,5));
    
    BinaryOperator min = BinaryOperator.minBy((o1,o2)->o1-o2);
    System.out.println(min.apply(100,200));
    BinaryOperator max = BinaryOperator.maxBy((o1,o2)->o1-o2);
    System.out.println(max.apply(100,200));
  }
}

例子里补充一点的是，BinaryOperator提供了两个默认的static快捷实现，帮助实现二元函数min(x,y)和max(x,y)，使用时注意的是排序器可别传反了：）

其他的Operator接口：（不解释了）

• LongUnaryOperator：long applyAsLong(long operand);
• IntUnaryOperator：int applyAsInt(int operand);
• DoubleUnaryOperator：double applyAsDouble(double operand);
• DoubleBinaryOperator：double applyAsDouble(double left, double right);
• IntBinaryOperator：int applyAsInt(int left, int right);
• LongBinaryOperator：long applyAsLong(long left, long right);

Predicate

predicate是一个谓词函数，主要作为一个谓词演算推导真假值存在，其意义在于帮助开发一些返回bool值的Function。本质上也是一个单元函数接口，其抽象方法test接受一个泛型参数T，返回一个boolean值。等价于一个Function的boolean型返回值的子集。

@FunctionalInterface
public interface Predicate {
  boolean test(T t);
  ...
}

其默认方法也封装了and、or和negate逻辑。写个小例子看看：

public class TestJ8Predicate {
  public static void main(String... args){
    TestJ8Predicate t = new TestJ8Predicate();
    t.pringBigValue(10, val->val>5);
    t.printBigValueAnd(10, val->val>5);
    t.printBigValueAnd(6, val->val>5);
  }
  public void pringBigValue(int value, Predicate predicate) {
    if (predicate.test(value)) {
      System.out.println(value);
    }
  }
  public void printBigValueAnd(int value, Predicate predicate) {
    if (predicate.and(v->v<8).test(value)) {
      System.out.println("value < 8:" + value);
    }else{
      System.out.println("value should < 8 at least.");
    }
  }
}

Predicate在Stream中有应用，Stream的filter方法就是接受Predicate作为入参的。这个具体在后面使用Stream的时候再分析深入。

其他Predicate接口：

• BiPredicate：boolean test(T t, U u);接受两个参数的二元谓词
• DoublePredicate：boolean test(double value);入参为double的谓词函数
• IntPredicate：boolean test(int value);入参为int的谓词函数
• LongPredicate：boolean test(long value);入参为long的谓词函数

Consumer

看名字就可以想到，这像谓词函数接口一样，也是一个Function接口的特殊表达——接受一个泛型参数，不需要返回值的函数接口。

@FunctionalInterface
public interface Consumer {
  void accept(T t);
  ...
}

这个接口声明太重要了，对于一些纯粹consume型的函数，没有Consumer的定义真无法被Function家族的函数接口表达。因为Function一定需要一个泛型参数作为返回值类型（当然不排除你使用Function来定义，但是一直返回一个无用的值）。比如下面的例子，如果没有Consumer，类似的行为使用Function表达就一定需要一个返回值。

public static void main(String... args) {
  Consumer consumer = System.out::println;
  consumer.accept(100);
  //use function, you always need one return value.
  Function function = x->{
    System.out.println(x);
    return x;
  }
  function.apply(100);
}

其他Consumer接口：

• BiConsumer：void accept(T t, U u);接受两个参数
• DoubleConsumer：void accept(double value);接受一个double参数
• IntConsumer：void accept(int value);接受一个int参数
• LongConsumer：void accept(long value);接受一个long参数
• ObjDoubleConsumer：void accept(T t, double value);接受一个泛型参数一个double参数
• ObjIntConsumer：void accept(T t, int value);接受一个泛型参数一个int参数
• ObjLongConsumer：void accept(T t, long value);接受一个泛型参数一个long参数

Supplier

其声明如下：

@FunctionalInterface
public interface Supplier {
  T get();
  ...
}

其简洁的声明，会让人以为不是函数。这个抽象方法的声明，同Consumer相反，是一个只声明了返回值，不需要参数的函数（这还叫函数？）。也就是说Supplier其实表达的不是从一个参数空间到结果空间的映射能力，而是表达一种生成能力，因为我们常见的场景中不止是要consume（Consumer）或者是简单的map（Function），还包括了new这个动作。而Supplier就表达了这种能力。

比如你要是返回一个常量，那可以使用类似的做法：

这保证supplier对象输出的一直是1。

如果是要利用构造函数的能力呢？就可以这样：

Supplier anotherSupplier;
for(int i=0; i<10; i++){
  anotherSupplier = TestJ8Supplier::new;
  System.out.println(anotherSupplier.get())
}

这样的输出可以看到，全部的对象都是new出来的。

这样的场景在Stream计算中会经常用到，具体在分析Java 8中Stream的时候再深入。

其他Supplier接口：
BooleanSupplier：boolean getAsBoolean();返回boolean
DoubleSupplier：double getAsDouble();返回double
IntSupplier：int getAsInt();返回int
LongSupplier：long getAsLong();返回long

参考：
阮一峰 - 函数式编程入门教程：http://www.ruanyifeng.com/blog/201
https://blog.csdn.net/lz710117239/article/details/76192629