简介

什么是函数式编程

函数式编程是一种编程范式，即一切都是数学函数。在Java面向对象编程中，程序是一系列相互作用（方法）的对象，而在函数式编程中，程序会是一个无状态的函数组合序列。

函数是“第一等公民”

“第一等公民”指的是函数和其他数据类型一样，处于平等的地位。可以赋值给变量、可以作为另一个函数的参数或者作为一个函数的返回值。比如

1
2
3
4
5
// 将两数相加的逻辑赋值给变量sum
var sum = (a,b)->a+b;

// 将函数作为另一个函数的参数
operation(sum)

Java函数试编程

Lambda 表达式

历史上研究函数式编程的理论是Lambda演算，所以我们经常把支持函数式编程的编码风格称为Lambda表达式。

在Java中Lambda 表达式的表达形式:

1
(参数)->方法体
  1. 参数：可以有多个，如果只有一个可以省略括号
  2. ->：箭头符号。
  3. 方法体：方法体超过一句时，要用{}包裹，可以根据情况看是否需要return语句

函数式接口

Java 8提供了函数式编程接口的概念，用作Lambda表达式的类型。

函数式接口：只定义了单一抽象方法的接口。

举个例子，看一下Java 8中Runnable接口 ： 

1
2
3
4
5
@FunctionalInterface
public interface Runnable {
    public abstract void run();
}

在类上多了一个@FunctionalInterface注解

Java 8之前定义一个Runnable 对象

1
2
3
4
5
Runnable r = new Runnable() {
   public void run() {
       System.out.println("Hello World!");
   }
};

Java 8之后可以直接写成

1
Runnable r =()-> System.out.println("Hello World!");

@FunctionalInterface注解并不是必须的，只要符合单一抽象方法的接口都可以。

用一个加减乘除的例子来演示一下Java中函数式编程的使用。

首先定义一个函数式接口，

1
2
3
4
5
6
public interface Operate {
    
    int operate(int a, int b);
    
}

将不同的逻辑操作赋值给函数式接口

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class Main {

    public static void main(String[] args) {
        // 加
        Operate add = (a, b) -> a + b;
        // 减
        Operate subtract = (a, b) -> a - b;
        // 乘
        Operate multiply = (a, b) -> a * b;
        // 除
        Operate divide = (a, b) -> a / b;
        
        System.out.println(operate(add, 2, 1));
        System.out.println(operate(subtract, 2, 1));
        System.out.println(operate(multiply, 2, 1));
        System.out.println(operate(divide, 2, 1));
    }

    static int operate(Operate operate, int a, int b) {
        return operate.operate(a, b);
    }
}

在上面的例子中，加减乘除的每个变量是一个个的函数，具体的函数逻辑在等号的右边。同时定义了一个operate的方法，第一个参数是Operate类型函数式接口，也就是接收的是一个函数，然后运行函数的逻辑，实际上是运行等号右边的逻辑。

在Java 8中，java.util.function下定义了许多函数式接口。列一下几个核心的函数式接口

接口 参数 返回类型 表述
Predicate T boolean 用于判断操作函数
Consumer T void 没有返回结果的函数
Function<T, R> T R 入参是T，出参是R的函数
Supplier T 生成一个对象T的函数
UnaryOperator T T 入参、出参都是T的类型函数
BinaryOperator (T,T) T 接收两个入参为T，出参也为T的函数

还是那上面加减乘除的例子，可以用BinaryOperator函数来表示,表示有两个入参是Integer出参也是Integer。

1
2
3
4
5
6
7
8
// 加
BinaryOperator<Integer> add = (a, b) -> a + b;
// 减
BinaryOperator<Integer> subtract = (a, b) -> a - b;
// 乘
BinaryOperator<Integer> multiply = (a, b) -> a * b;
// 除
BinaryOperator<Integer> divide = (a, b) -> a / b;

方法引用

方法引用是用来直接访问类或者实例的已经存在的方法或者构造方法,方法引用的本质其实是简化Lambda 表达式。

方法引用的使用是一对冒号::

类型 方法引用 对应的Lambda表达式
构造方法引用 类名::new (args) -> new 类名(args)
静态方法引用 类名:: 静态方法名 (args) -> 类名.staticMethod(args)
实例方法引用 类名::方法名 (inst,args) -> inst.method(args)
对象方法引用 对象::方法名 (args) -> 对象.method(args)

定义一个类来说明方法引用的使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
public class Person {

    private String name;

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public static void say(Person person) {
        System.out.println(person.getName());
    }

    public void equals(Person person) {
        System.out.println(this.getName().equals(person.getName()));
    }

    public void eat(String food) {
        System.out.println("eat " + food);
    }
}

构造方法引用

1
2
3
 Supplier<Person> supplier = Person::new;
//Lambda表达式写法
 Supplier<Person> supplier = ()-> new Person();

用Supplier函数式接口是因为调用的构造函数是无参的，符合Supplier函数式接口的定义

注意：被调用的方法的参数列表和返回值类型需要与函数式接口中抽象方法的参数列表和返回值类型要一致。

静态方法引用

1
2
3
Consumer<Person> say = Person::say;
//Lambda表达式写法
Consumer<Person> say = person -> Person.say(person);

用Consumer函数式接口是因为say方法是一个包含一个参数，并且没有返回值的函数，符合Consumer函数式接口的定义

注意：被调用的方法的参数列表和返回值类型需要与函数式接口中抽象方法的参数列表和返回值类型要一致。

实例方法引用

1
2
3
BiConsumer<Person, Person> personPersonBiConsumer = Person::equals;
//Lambda表达式写法
BiConsumer<Person, Person> personPersonBiConsumer = (inst, args) -> inst.equals(args);

实例方法引用第一个参数是实例方法的调用者，第二个是实例方法的参数。

注意：被调用的方法的参数列表和返回值类型需要与函数式接口中抽象方法的参数列表和返回值类型要一致。

对象方法引用

1
2
3
4
Person person = new Person();
Consumer<String> eat = person::eat;
// Lambda表达式写法
Consumer<String> eat = food -> person.eat(food);

注意：被调用的方法的参数列表和返回值类型需要与函数式接口中抽象方法的参数列表和返回值类型要一致。