函数式编程基础

前言

何谓函数式编程

编程语言主要有三种类型：

命令式编程：专注于“如何去做”，所有的事情都按照你的命令去做；
函数式编程：把运算的过程尽量表现成一系列的嵌套函数调用，相比命令式编程关心解决问题的步骤，它更关心数据之间的映射关系，是面向数学的抽象；
逻辑式编程：它通过设定答案必须符合的规则来解决问题，过程是事实加上规则就等于最后的结果。

函数式编程并不是java提出的新概念，在java8之前，我们关注的都是某一类对象有什么样的特性（抽象数据），当然这也是面向对象编程的基础，在java8出现之后，我们更加关注行为（抽象行为），这也是java8提出函数式编程的目的。至于lambda表达式，其实也就是为了支持函数式编程的。

函数式接口

为了支持lambda表达式，函数式接口应运而生。所谓的函数式接口指的是有且只有一个未实现的方法的接口，一般可以通过FunctionalInterface这个注解来表明接口是一个函数式接口。函数式接口是整个函数式编程的基础。java8之前其实就已经有一些函数式接口了，比如java.lang.Runnable，java.util.concurrent.Callable，java.util.Comparator等，java8更是提出了一些新的函数式接口：Supplier，Consumer，Function，Predicate。接下来本文将依次介绍java8提出的常用函数式接口，看看它们是怎么使我们的代码更加简洁更加优雅的。

Supplier

Supplier<T>代表了不接受任何参数就可以获取一种类型返回结果的操作，类似于工厂方法。它的方法定义如下：

T get();

我们来看个简单的使用示例：

@org.junit.Test
public void testSupplier() {
    Supplier<User> supplier = () -> new User("miaomiao", 24);
    System.out.println(supplier.get());
}

class User {
    /**
     * 用户名称
     */
    private String userName;

    /**
     * 用户年龄
     */
    private int age;

    public User(String userName, int age) {
        this.userName = userName;
        this.age = age;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "User{" +
                "userName='" + userName + '\'' +
                ", age=" + age +
                '}';
    }
}

Consumer

Consumer<T>代表了接受一个输入参数并且无返回的操作，如果某一类操作不需要返回接口，可以对该类操作抽取逻辑。它常用的方法定义如下：

void accept(T t);

除了该方法外，Consumer还提供andThen方法：

default Consumer<T> andThen(Consumer<? super T> after) {
    Objects.requireNonNull(after);
    return (T t) -> { accept(t); after.accept(t); };
}

从方法实现可以看出，在当前Consumer可以指定后续调用的其他Consumer。我们来通过一个简单的例子来看下它是如何使用的：

@org.junit.Test
public void testConsumer() {
    Consumer<String> before = System.out::println;
    Consumer<String> after = n -> System.out.println(n + "_test");
    //执行before
    before.accept("consumer");
    //先执行before再执行after
    before.andThen(after).accept("consumer");
}

运行结果：

consumer
consumer
consumer_test

Function

Function<T, R>代表了一个函数，它接受一个输入参数并且返回相应的一个结果。其中T代表函数输入，R代表函数输出。它主要有以下四个方法：apply，compose，andThen，identity：

//将Function对象应用到输入的参数上，然后返回计算结果
R apply(T t);

//返回一个先执行before函数对象的apply方法再执行当前函数对象的apply方法的函数对象
default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {
    Objects.requireNonNull(before);
    return (V v) -> apply(before.apply(v));
}

//返回一个先执行当前函数对象的apply方法再执行after函数对象的apply方法的函数对象
default <V> Function<T, V> andThen(Function<? super R, ? extends V> after) {
    Objects.requireNonNull(after);
    return (T t) -> after.apply(apply(t));
}

//返回一个不经过任何处理的函数对象，即输入与输出相等
static <T> Function<T, T> identity() {
    return t -> t;
}

其中需要注意的是，compose和andThen的不同之处就在于它们的函数调用顺序是不一样的。compose先执行参数函数再执行调用者，而andThen则先执行调用者再执行参数，这样看起来可能比较绕，我们来个简单的例子看一波：

@org.junit.Test
public void testFunction() {
    Function<Integer, Integer> add = n -> (n + 10);
    Function<Integer, Integer> square = n -> (n * n);
    //计算n + 10并返回结果
    System.out.println("add value = " + add.apply(10));
    //计算n * n并返回结果
    System.out.println("square value = " + square.apply(10));
    //先计算n * n，以其结果为参数计算n + 10
    System.out.println("compose value = " + add.compose(square).apply(10));
    //先计算n + 10，以其结果为参数计算n * n
    System.out.println("andThen value = " + add.andThen(square).apply(10));
    Object identity = Function.identity().apply("miaomiaoLoveCode");
    System.out.println(identity);
}

我们来看下输出结果：

add value = 20
square value = 100
compose value = 110
andThen value = 400
miaomiaoLoveCode

Predicate

Predicate<T>代表了接受一个输入参数，返回一个布尔值结果，主要用于判断输入参数是否满足某种条件，满足条件返回true，否则返回false。它有以下五个方法：test，and，negate，or，isEqual：

//判断输入参数是否满足某种条件
boolean test(T t);

//与
default Predicate<T> and(Predicate<? super T> other) {
    Objects.requireNonNull(other);
    return (t) -> test(t) && other.test(t);
}

//非
default Predicate<T> negate() {
    return (t) -> !test(t);
}

//或
default Predicate<T> or(Predicate<? super T> other) {
    Objects.requireNonNull(other);
    return (t) -> test(t) || other.test(t);
}

//判断两个值是否相等
static <T> Predicate<T> isEqual(Object targetRef) {
    return (null == targetRef)
            ? Objects::isNull
            : object -> targetRef.equals(object);
}

还是来个例子看一波：

@org.junit.Test
public void testPredicate() {
    Predicate<String> predicate1 = str -> str.equals("miao");
    Predicate<String> predicate2 = str -> str.startsWith("m");
    System.out.println(predicate1.test("miao"));
    System.out.println(predicate2.test("miaomiao"));
    System.out.println(predicate1.and(predicate2).test("miao"));
    System.out.println(predicate1.negate().test("miaomiaoLoveCode"));
    System.out.println(predicate1.or(predicate2).test("miaomiao"));
}