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

你可能感兴趣的:(java8--函数式编程)