java 函数式编程_java8的函数式编程解析

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

什么是函数式编程

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

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

函数接口

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,newComparator(){@Overridepublic 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的注解。如声明一个接口

@FunctionalInterfacepublic interface fun{}这会编译错，编译器会告诉你*no target method*。而如果加一个方法：@FunctionalInterfacepublic interface fun{void run();}这就OK了，一个函数式接口声明好了。再加一个呢？@FunctionalInterfacepublic interface fun{void run();void test();}不ok，明确说了只有一个抽象方法嘛。但是如果换一种函数签名：@FunctionalInterfacepublic interface fun{Object equals(Object o);void test();}这就OK了。一个抽象方法，一个Object的public方法，相安无事。Object还有其他方法，clone方法试试会怎么样？@FunctionalInterfacepublic 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();}@Overridepublic void run() {System.out.println("run");}@Overridepublic void foo() {System.out.println("foo");}@Overridepublic void voo() {System.out.println("voo");}}函数式接口的一大特性就是可以被lambda表达式和函数引用表达式代替。public class FunTest {public static void main(String... args) {FunTest t = new FunTest();//lambdat.test(10, ()->System.out.println("xxxxx"))//method referencet.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);}}@FunctionalInterfaceinterface Action {public void execute(T t);}

Function

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

@FunctionalInterfacepublicinterfaceFunction{Rapply(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 lambdaFunction(){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));}控制台输出：-------------------------------------------------------f(x)=x+1,when x=2, f(x)=4f(x)=x+1,g(x)=2x, when x=2,f(g(x))=8f(x)=x+1,g(x)=2x, when x=2,g(f(x))=8compose vs andThen: f(g(x))=8,8

高阶函数

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

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

//high orderfunctionFunction> makeAdder = z->y->z+y;x=2;//defineadd1Function add1 = makeAdder.apply(1);System.out.println("f(x)=x+1,when x="+x+",f(x)="+add1.apply(x));//defineadd5Function add5 = makeAdder.apply(5);System.out.println("f(x)=x+5, when x="+x+", f(x)="+add5.apply(x));

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

//binaryfunBiFunction 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。分别对应单元算子和二元算子。算子的接口声明如下：

@FunctionalInterfacepublicinterfaceUnaryOperatorextendsFunction{staticUnaryOperatoridentity(){return t->t;}}

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

publicclassTestOperator{publicstaticvoidmain(String... args){UnaryOperatoradd= 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型返回值的子集。

@FunctionalInterfacepublicinterfacePredicate{booleantest(T t);...}

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

publicclassTestJ8Predicate{publicstaticvoidmain(String... args){TestJ8Predicate t =newTestJ8Predicate();t.pringBigValue(10, val->val>5);t.printBigValueAnd(10, val->val>5);t.printBigValueAnd(6, val->val>5);}publicvoidpringBigValue(intvalue, Predicate predicate){if(predicate.test(value)){System.out.println(value);}}publicvoidprintBigValueAnd(intvalue, 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接口的特殊表达——接受一个泛型参数，不需要返回值的函数接口。

@FunctionalInterfacepublicinterfaceConsumer{voidaccept(T t);...}

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

publicstaticvoidmain(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

其声明如下：

@FunctionalInterfacepublicinterfaceSupplier{Tget();...}

其简洁的声明，会让人以为不是函数。这个抽象方法的声明，同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();返回booleanDoubleSupplier：double getAsDouble();返回doubleIntSupplier：int getAsInt();返回intLongSupplier：long getAsLong();返回long