java8--函数式编程

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

什么是函数式编程

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

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

fun.png

函数接口

接口 参数 返回类型 描述
Predicate<T> T boolean 用来比较操作
Consumer<T> T void 没有返回值的函数
Function<T, R> T R 有返回值的函数
Supplier<T> None T 工厂方法-返回一个对象
UnaryOperator<T> T T 入参和出参都是相同对象的函数
BinaryOperator<T> (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<String> names = Arrays.asList("peter", "anna", "mike", "xenia");
Collections.sort(names, new Comparator<String>() {
    @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<T> {
    public void execute(T t);
}

Function

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

@FunctionalInterface
public interface Function<T,R>{
  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<Integer, Integer> incr1 = x->x*2;
        Function<Integer, Integer> 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<Integer, Function<Integer, Integer>> makeAdder = z->y->z+y;
x=2;
//define add1
Function<Integer, Integer> add1 = makeAdder.apply(1);
System.out.println("f(x)=x+1,when x="+x+",f(x)="+add1.apply(x));
//define add5
Function<Integer, Integer> add5 = makeAdder.apply(5);
System.out.println("f(x)=x+5, when x="+x+", f(x)="+add5.apply(x));

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

//binary fun
BiFunction<Integer, Integer, Integer> 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<T> extends Function<T, T> {
  static <T> UnaryOperator<T> identity(){
    return t->t;
  }
}

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

public class TestOperator {
  public static void main(String... args) {
    UnaryOperator<Integer> add = x->x+1;
    System.out.println(add.apply(1))
    
    BinaryOperator<Integer> addxy = (x,y)->x+y;
    System.out.println(addxy.apply(3,5));
    
    BinaryOperator<Integer> min = BinaryOperator.minBy((o1,o2)->o1-o2);
    System.out.println(min.apply(100,200));
    BinaryOperator<Integer> 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<T> {
  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<Integer> predicate) {
    if (predicate.test(value)) {
      System.out.println(value);
    }
  }
  public void printBigValueAnd(int value, Predicate<Integer> 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<T> {
  void accept(T t);
  ...
}

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

public static void main(String... args) {
  Consumer<Integer> consumer = System.out::println;
  consumer.accept(100);
  //use function, you always need one return value.
  Function<Integer,Integer> 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> {
  T get();
  ...
}

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

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

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

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

Supplier<TestJ8Supplier> 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

©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 158,560评论 4赞 361
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 67,104评论 1赞 291
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 108,297评论 0赞 243
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 43,869评论 0赞 204
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 52,275评论 3赞 287
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 40,563评论 1赞 216
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 31,833评论 2赞 312
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 30,543评论 0赞 197
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 34,245评论 1赞 241
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 30,512评论 2赞 244
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 32,011评论 1赞 258
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 28,359评论 2赞 253
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 33,006评论 3赞 235
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 26,062评论 0赞 8
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 26,825评论 0赞 194
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 35,590评论 2赞 273
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 35,501评论 2赞 268