函数式编程基础

前言

何谓函数式编程

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

  1. 命令式编程:专注于“如何去做”,所有的事情都按照你的命令去做;

  2. 函数式编程:把运算的过程尽量表现成一系列的嵌套函数调用,相比命令式编程关心解决问题的步骤,它更关心数据之间的映射关系,是面向数学的抽象;

  3. 逻辑式编程:它通过设定答案必须符合的规则来解决问题,过程是事实加上规则就等于最后的结果。

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

函数式接口

为了支持lambda表达式,函数式接口应运而生。所谓的函数式接口指的是有且只有一个未实现的方法的接口,一般可以通过FunctionalInterface这个注解来表明接口是一个函数式接口。函数式接口是整个函数式编程的基础。java8之前其实就已经有一些函数式接口了,比如java.lang.Runnablejava.util.concurrent.Callablejava.util.Comparator等,java8更是提出了一些新的函数式接口:SupplierConsumerFunctionPredicate。接下来本文将依次介绍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代表函数输出。它主要有以下四个方法:applycomposeandThenidentity

//将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;
}

其中需要注意的是,composeandThen的不同之处就在于它们的函数调用顺序是不一样的。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。它有以下五个方法:testandnegateorisEqual

//判断输入参数是否满足某种条件
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"));
}

运行结果:

true
true
true
true
true

到这里为止,java8的函数式编程就扫盲完毕,看,使用函数式编程后我们的代码是不是更简短了,其实代码还可以更精简些。ps:后文将会继续介绍另外两个精简代码神器:Stream和Optional,欢迎大家持续关注呀~

推荐阅读更多精彩内容