简介： Java是面向对象的语言，无奈间接调用一个函数。Java 8开始，引入了函数式编程接口与Lambda表达式，便于开发者写出更少更优雅的代码。什么是函数式编程？函数式编程的特点是什么？本文通过代码实例，从Stream类、Lambda表达式和函数接口这三个语法概念来分享Java对函数式编程的反对。

背景

在很长的一段时间里，Java始终是面向对象的语言，所有皆对象，如果想要调用一个函数，函数必须属于一个类或对象，而后在应用类或对象进行调用。然而在其它的编程语言中，如JS、C++，咱们能够间接写一个函数，而后在须要的时候进行调用，既能够说是面向对象编程，也能够说是函数式编程。从性能上来看，面向对象编程没什么不好的中央，然而从开发的角度来看，面向对象编程会多写很多可能是反复的代码行。比方创立一个Runnable的匿名类的时候：

Runnable runnable = new Runnable() {    @Override    public void run() {        System.out.println("do something...");    }};

这一段代码中真正有用的只有run办法中的内容，残余的局部都是属于Java编程语言的构造局部，没什么用，然而要写。侥幸的是Java 8开始，引入了函数式编程接口与Lambda表达式，帮忙咱们写更少更优雅的代码：

// 一行即可Runnable runnable = () -> System.out.println("do something...");

当初支流的编程范式次要有三种，面向过程、面向对象和函数式编程。

函数式编程并非一个很新的货色，早在50多年前就曾经呈现了。近几年，函数式编程越来越被人关注，呈现了很多新的函数式编程语言，比方Clojure、Scala、Erlang等。一些非函数式编程语言也退出了很多个性、语法、类库来反对函数式编程，比方Java、Python、Ruby、JavaScript等。除此之外，Google Guava也有对函数式编程的加强性能。

函数式编程因其编程的特殊性，仅在科学计算、数据处理、统计分析等畛域，能力更好地施展它的劣势，所以它并不能齐全代替更加通用的面向对象编程范式。然而作为一种补充，它也有很大存在、倒退和学习的意义。

什么是函数式编程

函数式编程的英文翻译是Functional Programming。

那到底什么是函数式编程呢？实际上，函数式编程没有一个严格的官网定义。严格上来讲，函数式编程中的“函数”，并不是指咱们编程语言中的“函数”概念，而是指数学“函数”或者“表达式”（例如：y=f(x)）。不过，在编程实现的时候，对于数学“函数”或“表达式”，咱们个别习惯性地将它们设计成函数。所以，如果不深究的话，函数式编程中的“函数”也能够了解为编程语言中的“函数”。

每个编程范式都有本人独特的中央，这就是它们会被形象进去作为一种范式的起因。面向对象编程最大的特点是：以类、对象作为组织代码的单元以及它的四大个性。面向过程编程最大的特点是：以函数作为组织代码的单元，数据与办法相拆散。那函数式编程最独特的中央又在哪里呢？实际上，函数式编程最独特的中央在于它的编程思维。函数式编程认为程序能够用一系列数学函数或表达式的组合来示意。函数式编程是程序面向数学的更底层的形象，将计算过程形容为表达式。不过，这样说你必定会有疑难，真的能够把任何程序都示意成一组数学表达式吗？

实践上讲是能够的。然而，并不是所有的程序都适宜这么做。函数式编程有它本人适宜的利用场景，比方科学计算、数据处理、统计分析等。在这些畛域，程序往往比拟容易用数学表达式来示意，比起非函数式编程，实现同样的性能，函数式编程能够用很少的代码就能搞定。然而，对于强业务相干的大型业务零碎开发来说，吃力吧啦地将它形象成数学表达式，硬要用函数式编程来实现，显然是自讨苦吃。相同，在这种利用场景下，面向对象编程更加适合，写进去的代码更加可读、可保护。

再具体到编程实现，函数式编程跟面向过程编程一样，也是以函数作为组织代码的单元。不过，它跟面向过程编程的区别在于，它的函数是无状态的。何为无状态？简略点讲就是，函数外部波及的变量都是局部变量，不会像面向对象编程那样，共享类成员变量，也不会像面向过程编程那样，共享全局变量。函数的执行后果只与入参无关，跟其余任何内部变量无关。同样的入参，不管怎么执行，失去的后果都是一样的。这实际上就是数学函数或数学表达式的根本要求。举个例子：

// 有状态函数: 执行后果依赖b的值是多少，即使入参雷同，// 屡次执行函数，函数的返回值有可能不同，因为b值有可能不同。int b;int increase(int a) {  return a + b;}// 无状态函数：执行后果不依赖任何内部变量值// 只有入参雷同，不论执行多少次，函数的返回值就雷同int increase(int a, int b) {  return a + b;}

不同的编程范式之间并不是截然不同的，总是有一些雷同的编程规定。比方不论是面向过程、面向对象还是函数式编程，它们都有变量、函数的概念，最顶层都要有main函数执行入口，来组装编程单元（类、函数等）。只不过，面向对象的编程单元是类或对象，面向过程的编程单元是函数，函数式编程的编程单元是无状态函数。

Java对函数式编程的反对

实现面向对象编程不肯定非得应用面向对象编程语言，同理，实现函数式编程也不肯定非得应用函数式编程语言。当初，很多面向对象编程语言，也提供了相应的语法、类库来反对函数式编程。

Java这种面向对象编程语言，对函数式编程的反对能够通过一个例子来形容：

public class Demo {  public static void main(String[] args) {    Optional<Integer> result = Stream.of("a", "be", "hello")            .map(s -> s.length())            .filter(l -> l <= 3)            .max((o1, o2) -> o1-o2);    System.out.println(result.get()); // 输入2  }}

这段代码的作用是从一组字符串数组中，过滤出长度小于等于3的字符串，并且求得这其中的最大长度。

Java为函数式编程引入了三个新的语法概念：Stream类、Lambda表达式和函数接口（Functional Inteface）。Stream类用来反对通过“.”级联多个函数操作的代码编写形式；引入Lambda表达式的作用是简化代码编写；函数接口的作用是让咱们能够把函数包裹成函数接口，来实现把函数当做参数一样来应用（Java 不像C那样反对函数指针，能够把函数间接当参数来应用）。

Stream类

假如咱们要计算这样一个表达式：(3-1)*2+5。如果依照一般的函数调用的形式写进去，就是上面这个样子：

add(multiply(subtract(3,1),2),5);

不过，这样编写代码看起来会比拟难了解，咱们换个更易读的写法，如下所示：

subtract(3,1).multiply(2).add(5);

在Java中，“.”示意调用某个对象的办法。为了反对下面这种级联调用形式，咱们让每个函数都返回一个通用的Stream类对象。在Stream类上的操作有两种：两头操作和终止操作。两头操作返回的依然是Stream类对象，而终止操作返回的是确定的值后果。

再来看之前的例子，对代码做了正文解释。其中map、filter是两头操作，返回Stream类对象，能够持续级联其余操作；max是终止操作，返回的不是Stream类对象，无奈再持续往上级联解决了。

public class Demo {  public static void main(String[] args) {    Optional<Integer> result = Stream.of("f", "ba", "hello") // of返回Stream<String>对象            .map(s -> s.length()) // map返回Stream<Integer>对象            .filter(l -> l <= 3) // filter返回Stream<Integer>对象            .max((o1, o2) -> o1-o2); // max终止操作：返回Optional<Integer>    System.out.println(result.get()); // 输入2  }}

Lambda表达式

后面提到Java引入Lambda表达式的次要作用是简化代码编写。实际上，咱们也能够不必Lambda表达式来书写例子中的代码。咱们拿其中的map函数来举例说明。

上面三段代码，第一段代码展现了map函数的定义，实际上，map函数接管的参数是一个Function接口，也就是函数接口。第二段代码展现了map函数的应用形式。第三段代码是针对第二段代码用Lambda表达式简化之后的写法。实际上，Lambda表达式在Java中只是一个语法糖而已，底层是基于函数接口来实现的，也就是第二段代码展现的写法。

// Stream类中map函数的定义：public interface Stream<T> extends BaseStream<T, Stream<T>> {  <R> Stream<R> map(Function<? super T, ? extends R> mapper);  //...省略其余函数...}// Stream类中map的应用办法示例：Stream.of("fo", "bar", "hello").map(new Function<String, Integer>() {  @Override  public Integer apply(String s) {    return s.length();  }});// 用Lambda表达式简化后的写法：Stream.of("fo", "bar", "hello").map(s -> s.length());

Lambda表达式包含三局部：输出、函数体、输入。示意进去的话就是上面这个样子：

(a, b) -> { 语句1；语句2；...; return 输入; } //a,b是输出参数

实际上，Lambda表达式的写法非常灵活。下面给出的是规范写法，还有很多简化写法。比方，如果输出参数只有一个，能够省略 ()，间接写成 a->{…}；如果没有入参，能够间接将输出和箭头都省略掉，只保留函数体；如果函数体只有一个语句，那能够将{}省略掉；如果函数没有返回值，return语句就能够不必写了。

Optional<Integer> result = Stream.of("f", "ba", "hello")        .map(s -> s.length())        .filter(l -> l <= 3)        .max((o1, o2) -> o1-o2);        // 还原为函数接口的实现形式Optional<Integer> result2 = Stream.of("fo", "bar", "hello")        .map(new Function<String, Integer>() {          @Override          public Integer apply(String s) {            return s.length();          }        })        .filter(new Predicate<Integer>() {          @Override          public boolean test(Integer l) {            return l <= 3;          }        })        .max(new Comparator<Integer>() {          @Override          public int compare(Integer o1, Integer o2) {            return o1 - o2;          }        });

Lambda表达式与匿名类的异同集中体现在以下三点上：

  • Lambda就是为了优化匿名外部类而生，Lambda要比匿名类简洁的多得多。
  • Lambda仅实用于函数式接口，匿名类不受限。
  • 即匿名类中的this是“匿名类对象”自身；Lambda表达式中的this是指“调用Lambda表达式的对象”。

函数接口

实际上，下面一段代码中的Function、Predicate、Comparator都是函数接口。咱们晓得，C语言反对函数指针，它能够把函数间接当变量来应用。

然而，Java没有函数指针这样的语法。所以它通过函数接口，将函数包裹在接口中，当作变量来应用。实际上，函数接口就是接口。不过，它也有本人特地的中央，那就是要求只蕴含一个未实现的办法。因为只有这样，Lambda表达式能力明确晓得匹配的是哪个办法。如果有两个未实现的办法，并且接口入参、返回值都一样，那Java在翻译Lambda表达式的时候，就不晓得表达式对应哪个办法了。

函数式接口也是Java interface的一种，但还须要满足：

  • 一个函数式接口只有一个形象办法(single abstract method)；
  • Object类中的public abstract method不会被视为繁多的形象办法；
  • 函数式接口能够有默认办法和静态方法；
  • 函数式接口能够用@FunctionalInterface注解进行润饰。

满足这些条件的interface，就能够被视为函数式接口。例如Java 8中的Comparator接口：

@FunctionalInterfacepublic interface Comparator<T> {    /**     * single abstract method     * @since 1.8     */    int compare(T o1, T o2);    /**     * Object类中的public abstract method      * @since 1.8     */    boolean equals(Object obj);    /**     * 默认办法     * @since 1.8     */    default Comparator<T> reversed() {        return Collections.reverseOrder(this);    }        /**     * 静态方法     * @since 1.8     */    public static <T extends Comparable<? super T>> Comparator<T> reverseOrder() {        return Collections.reverseOrder();    }    //省略...}

函数式接口有什么用呢？一句话，函数式接口带给咱们最大的益处就是：能够应用极简的lambda表达式实例化接口。为什么这么说呢？咱们或多或少应用过一些只有一个形象办法的接口，比方Runnable、ActionListener、Comparator等等，比方咱们要用Comparator实现排序算法，咱们的解决形式通常无外乎两种：

  • 规规矩矩的写一个实现了Comparator接口的Java类去封装排序逻辑。若业务须要多种排序形式，那就得写多个类提供多种实现，而这些实现往往只需应用一次。
  • 另外一种聪慧一些的做法无外乎就是在须要的中央搞个匿名外部类，比方：
public class Test {     public static void main(String args[]) {         List<Person> persons = new ArrayList<Person>();        Collections.sort(persons, new Comparator<Person>(){            @Override            public int compare(Person o1, Person o2) {                return Integer.compareTo(o1.getAge(), o2.getAge());            }        });    } }

匿名外部类实现的代码量没有多到哪里去，构造也还算清晰。Comparator接口在Jdk 1.8的实现减少了FunctionalInterface注解，代表Comparator是一个函数式接口，使用者可释怀的通过lambda表达式来实例化。那咱们来看看应用lambda表达式来疾速new一个自定义比拟器所须要编写的代码：

Comparator<Person> comparator = (p1, p2) -> Integer.compareTo(p1.getAge(), p2.getAge());

-> 后面的 () 是Comparator接口中compare办法的参数列表，-> 前面则是compare办法的办法体。

上面将Java提供的Function、Predicate这两个函数接口的源码，摘抄如下：

@FunctionalInterfacepublic interface Function<T, R> {    R apply(T t);  // 只有这一个未实现的办法    default <V> Function<V, R> compose(Function<? super V, ? extends T> before) {        Objects.requireNonNull(before);        return (V v) -> apply(before.apply(v));    }    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;    }}@FunctionalInterfacepublic interface Predicate<T> {    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);    }}

@FunctionalInterface注解应用场景

咱们晓得，一个接口只有满足只有一个形象办法的条件，即能够当成函数式接口应用，有没有 @FunctionalInterface 都无所谓。然而jdk定义了这个注解必定是有起因的，对于开发者，该注解的应用肯定要三思而后续行。

如果应用了此注解，再往接口中新增形象办法，编译器就会报错，编译不通过。换句话说，@FunctionalInterface 就是一个承诺，承诺该接口世世代代都只会存在这一个形象办法。因而，但凡应用了这个注解的接口，开发者可放心大胆的应用Lambda来实例化。当然误用 @FunctionalInterface 带来的结果也是极其惨重的：如果哪天你把这个注解去掉，再加一个形象办法，则所有应用Lambda实例化该接口的客户端代码将全副编译谬误。

特地地，当某接口只有一个形象办法，但没有用 @FunctionalInterface 注解润饰时，则代表他人没有承诺该接口将来不减少形象办法，所以倡议不要用Lambda来实例化，还是老老实实的用以前的形式比拟稳当。

小结

函数式编程更合乎数学上函数映射的思维。具体到编程语言层面，咱们能够应用Lambda表达式来疾速编写函数映射，函数之间通过链式调用连贯到一起，实现所需业务逻辑。Java的Lambda表达式是起初才引入的，因为函数式编程在并行处理方面的劣势，正在被大量利用在大数据计算畛域。