拥抱新时代的Java

原文链接 拥抱新时代的Java

Java作为面向对象编程的王牌语言，曾经风靡一时，在Web领域是绝对的老大。随着时间的推移，一些新的编程范式不断的涌现，如函数式编程，响应式编程，以及对函数的全力支持（Lambda函数）变成了大家经常谈论的话题。移动互联网的出现，以及前端的流行，让新一代的编程语言如Scala，Groovy，Swift以及Kotlin都大受欢迎。以函数式编程为核心的新一代编程范式慢慢变成了主流。曾经的王者Java，一度被人垢病，因为对函数支持不友好，（其实最主要的原因是如何保持好向后兼容），但也与时俱进，终于在Java 8版本迈出了重大的一步，完全支持了函数式编程。本篇将重点讨论Java 8的新特性，以及如何用Java 8来实践函数式编程。

Lambda表达式

也即匿名函数，称之为lambda。具体数学上的定义比较复杂就不多说了。为了便于理解，我们先从匿名内部类说起。

Java早就支持匿名内部类，这是在当年相比较C++一个重要大的提升，它在一些需要提供行为实现的地方还是非常方便的，典型的例子就是UI中的点击事件的处理：

button.addActionListener(new ActionListener() {
    @Override
    void actionPerformed(ActionEvent e) {
        System.out.println("Button is clicked: " + e);
    }
});

这里的要点就是我们向button传递的是一个行为，也就是说按扭点击了时，要执行什么样的行为。对比其他现代语言，这还是显得有些笨重，没有简单明了的说明意图。用Java 8，这就好办多了，可以这样写：

button.addActionListener(e -> System.out.println("Button is clicked: " + e);

括号里面这一坨就是一个Lambda表达式，它是一个行为（严格来说是一个函数），用以直接向目标对象传递一个行为，对比前面的例子，可以发现，这种场景下使用Lambda更加的简洁高效。

Lambda表达式的语法

它的通用语法是：

(p1, p2....) -> {
    statements;
}

括号里面是参数列表，当只有一个参数时，括号可省略，但当参数多于1个时，或者显示声明了参数类型时，括号不能省略，如：

names.sort((a, b) -> b.compareTo(a));
button.addActionListener((ActionEvent e) -> System.out.println("Button is clicked: " + e));

花括号中就是语句块了，这跟常规语句块（如if， while等）是一样的，如果有返回值就return，把它理解为常规方法的实体就可以了，像写常规函数实现那样去写就好了。如果只有一个语句，或者一条表达式，可以省略花括号。

类型推断

Lambda表达是匿名函数，主要用以向目标对象传递行为，既然匿名，当然是图简洁和清晰，因此就不要弄的太复杂。所以，参数的类型，以及表达式的返回值（如有）的类型，都是编译器通过上下文来推断出来的，因此，不用给参数写类型，如果因为实现的接口不明确，编译器看不懂的话，会有编译报错的。

关于类型推断可以看《Java 8函数式编程》的第2章第5节有详细的讨论。

闭包

也就是closure，严格的数学定义就不说了，有点复杂和难于理解，简单来说就是Lambda表达中使用了一个其定义域外的变量的值（称作捕获外部变量），lambda即变成了一个闭包。还是有点绕，这个其实并不陌生，以前的匿名内部就是可以使用外部变量的，只不过编译器要强加final修饰，如：

final int numberOfStudents = countStudents();
button.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
        System.out.println("Number of students is " + numberOfStudents);
    }
}

这里其实就是一个闭包了，匿名内部类中捕获了外部的变量numberOfStudents，只不过要强加final修饰，这是因为这里要传值。

Java 8里面呢，外部变量不必用final修饰了，但是，它也必须实际上是final的：

int numberOfStudents = countStudents();
button.addActionListener(e -> System.out.println("Number of students is " + numberOfStudents));

因为，之前啊，假如捕获了一个外部变量，不是final的，会有编译错误，但如果你用IDE的建议时，它就直接再声明一个final变量，用原变量赋值，然后把新的final变量传给匿名内部类，如：

int numberOfStudents = countStudents();
final int finalNumberOfStudents = numberOfStudents;
button.addActionListener(new ActionListener() {
    @Override
    public void actionPerformed(ActionEvent e) {
        System.out.println("Number of students is " + finalNumberOfStudents);
    }
}

到此就明白了，Java 8对于闭包的支持，其实较之前没有实质的变化，只不过编译器帮你做了这个final变量的定义而已。

这部分可以参考《Java 8函数式编程》中第2章第3节的内容。

接口方法默认实现

Java 8中，可以给接口interface，添加一个方法的默认实现，这样在实现此接口时，子类可以选择重新实现，或者不实现，直接调用此方法即可，从语法上来说，是比较简单的，用default关键字来修饰方法即可，如：

interface Formula {
    double calculate(int a);
    
    default double sqrt(int a) {
        return Math.sqrt(a);
    }
}

class ComplexFormula implements Formula {
    double calculate(int a) {
         return super.sqrt(real) + super.sqrt(imaginary);
    }
}

这里面，子类ComplexFormula是可以正常编译和运行的。

注意：接口是支持多重继承的，比如一个类可以实现多个接口，这就有可能存在接口中有相同的默认方法，最好的处理方法就是子类重新实现一下此方法，然后可以用接口的名字+super来具体指定父类中的方法。这一具体的规则比较复杂，可以看《Java 8函数式编程》这本书中的第4章第7节，有比较详细的论述。

另外，需要注意，实际运用中，接口的默认方法并不常用，因为这本身就是比较奇怪的，与最初Java的设计有冲突，接口策重于行为的高级抽象，而抽象类侧重对象的高级抽象（多半涉及状态属性）。这东西的出现主要是为了解决向后兼容，比如说当你一个被广泛使用的接口添加了一个新的方法时，所有实现此接口的类必须全部要改一遍，要实现此接口，这会影响大量的现存代码，而默认方法就是为了解决这个问题的，给新添加的方法标记为default，就不会影响现存代码了。

这个可以仔细读一下《Java 8函数式编程》中的第4章第6节和第7节的内容。

函数接口

支持函数式编程范式的语言一般来说呢，会把函数作为语义上的一级类型，比如像Python或者Kotlin都有专门用于声明函数的关键字。另外，需要澄清一下函数的概念，简单来说函数就是给定一些输入，然后给出输出，输出随输入改变而改变，不会产生副作用，也就是不会修改全局变量，不会修改环境变量。且具有幂等性，即针对 同一组输入，多次调用，结果仍是一样的，这就是函数。

对于Java，这事儿就有点难办了，因为前面的版本根本就没有把方法独立成为函数，方法必须存在于类中。为了支持函数，函数是函数式编程的基本要素，所以要想支持函数式编程，必须以某种方式来支持函数的定义。Java 8中就提出了函数接口的概念。

函数接口是只有一个抽象方法的接口，这里有两个关键信息，首先，语义上的类型必须是一个interface，其次，它只能有一个抽象方法，放在以前的版本，其实意思就是说只有能一个方法，但还要注意的是前面提到的默认方法。那么这里的要求就是除了默认方法以外，只能有一个方法。

函数接口必须用*@FunctionalInterface*注解来标注，编译器会对它做特别的关注，一旦有超过1个抽象接口，就会编译报错。为啥要用注解而不是增加关键字（如function），或者创建一级类型（如function interface），目的仍是向后兼容。注解仅需要在编译阶段做一些额外的事情即可，这即实现了扩展，又保持了兼容性。

前面提到的Lambda表达式必须是一个函数接口的实例，这样说太抽象了，慢慢来解释下。Lambda是一个匿名函数，可以把它理解为一个对象，它所实现的必须是一个函数接口。换句话说，只有声明为函数接口的地方，也就是方法的参数类型或者变量的类型要声明为函数接口，只有这里才可以传入lambda表达式。

接着前面的Formula例子，假如有如下应用场景：

class Number {
    int payload;
    public Number transform(Formula formula) {
         return formula.calculate(payload);
    }
}

现在调用transform方法时如果直接传递lambda，是会报错的：

number.transform(a -> a * a); // won't compile

解决方法，就是要给Formula添加函数接口注解：

@FunctionalInterface
interface Formula {
    double calculate(int a);
    
    default double sqrt(int a) {
        return Math.sqrt(a);
    }
}

关于函数接口，可以参阅《Java 8函数式编程》中第2章第4节和第4章第4节。

常用的函数接口

Java 8 定义了一些非常常用的函数接口，这里做一下简单的介绍。

Predict

断言，给定一个类型为T的输入，给出boolean的输出（true of false）。通常用于过滤操作之中：

Predict<String> isEmpty = String::isEmpty;
students.stream()
    .filter(name -> !name.isEmpty());

Function

通用的函数操作，给定类型为T的输入，返回类型为R的输出，通常用于map之中：

Function<String, int> length = name -> name.length();

其实，Predict可视为一种特殊的Function，它的返回类型是boolean。

Consumer

消费类型为T的对象，无输出，作为调用链的终点，通常用于生成终值，如前面例子中传给button的lambda就一个Consumer。

Supplier

返回一个类型为T的对象，也即生产者，通常都是用于工厂方法，用来生成新的对象。

UnaryOperator

一元操作符，输入类型是T的对象，返回类型是T的对象：

UnaryOperator<Integer> square = x -> x * x;

BinaryOperator

二元操作符，输入参数是类型同为T的a和b两个参数，输出是一个类型为T的结果：

BinaryOperator<String> join = (first, second) -> first + ", " + second;

这里例子不是很多，因为单独写这些函数接口的lambda不太好写，且意义不够实用，会在后面结合Stream API，给出更多示例。

Optional

这个类用于封装可能为空的对象，以更好的处理null的情况，它加强了类型检查（null本身是没有类型的），以及使用时的空值检查，所以可以一定程度上防止NullPointerException的出现。

先来看一下它的简单使用方法：

Optional<String> a = Optional.of("a");
System.out.println(a.get()); // a
Optional empty = Optional.empty(); // 返回一个为空的对象
System.out.println(empty.isPresent()); // false
System.out.println(empty.orElse("b"); // b
System.out.println(empty.orElseGet(() -> "c")); // c

前面2行好理解了，第3行创建一个为空的Optional对象，它的isPresent会返回false，orElse是说如果为空时可以返回一个默认值『b』，而最后一行也可以为默认值提供一个Supplier以在为空的时候产生一个值。

通过这几个小例子可以看出Optional的用途，它可以比较好的封装对象，并提前定义值不存在时的应对情况，能够一定程序上减少NPE。

不过，这个东西对于复杂项目来说效用不会太大，假如你到处判断isPresent，其实跟检测== null也没有本质区别。实际项目中大量的NPE来自于多线程环境共享成员变量，这种情况下Optional也救不了你。

要想发挥这东西的最大效用，需要从设计角度尽可能的减少变量共享，尽可能的缩小变量作用域，再配合默认值或者默认值的Suppiier，多管齐下，才能有效的防止NPE。

方法引用

函数式编程，函数要是语义层面的一级类型，变量或者参数的类型可以是函数，前面提到了在Java 8中代表函数类型就是函数接口。

那么，当传递具体函数体的时候，我们一直在使用lambda表达式，但这并不是适合所有场景，比如说我已经有了一个类的方法，完全符合函数接口的方法签名，难道还非要写一个lambda吗？

button.addActionListener(event -> System.out.println(event));
Predict<String> empty = str -> str.isEmpty();
Function<Artist, String> namer = artist -> artist.getName();

这显然太啰嗦了，这种情况下，可以直接用方法引用，来把已有的方法传递过去，形式是类名::方法名，用方法引用重写上面的几个小例子：

button.addActionListener(System.out::println);
Predict<String> empty = String::isEmpty;
Function<Artist, String> namer = Artist::getName;

简洁了很多吧，不但可以复用已有的方法，简洁明了，而且也省去创建一个lambda对象。一定要注意的就是要用方法的名字，不能加括号，因为加了括号，在语义上就是对函数的调用了，引用的便是该方法的返回值，除非这个方法的返回值是一个函数接口实例（lambda或者一个方法引用）。

除了常规方法可以用作引用以外，还可以对构造方法进行引用，格式是类名::new，如

Artist::new; // 相当于  (name, nationality) -> new Artist(name, nationality);

可以参阅《Java 8函数式编程》第5章第1节的内容。

Stream API

终于到了最为重要的特性了，为了更进一步的支持函数式编程，Java 8新增了Stream API，它是针对集合类型（List，Map和Set等）函数式操作的支持，以更好的把行为与遍历分离。先来看一下小例子：

比如有这样一个列表：

List<String> giants = List.of("Apple", "Google", "Microsoft", "Facebook", "Tesla");

想简单遍历一下，以前这么写：

 for (String item : giants) {
     System.out.println(item);
 }

但，现在只需要这样写就可以了：

giants.forEach(System.out::println);

是不是很清爽，这就是典型的函数式写法，你可能会说就这？客官别急，这只是前戏，后面还有更刺激的。

注意：这里一定要与I/O stream区分开来，完全是两个东西。Stream API是针对 集合操作的函数式支持。

函数式编程核心元素是函数，它通过对函数的各种组合得到最终的结果，最为典型的就是流式调用，把函数串连起来，或者叫做链式调用，让数据在函数链中流动，最终得到期望的结果。最为经典的函数式『三板斧』就是过滤（filter），转换（map）和折叠（也称化约，英文是reduce），这是所有函数式程序的基本构造单元。可以参阅《函数式编程思维》这本书的第2章，有比较详细的讨论。

复杂的实例

为了更好的演示Java 8的Stream API，以及综合运用函数式方法，本文剩余部分，将基于Brooklyn的球员技术统计信息操作为基础的实例。球队中有多名球员，每个球员有一些基本信息和一组比赛技术统计，现在教练需要对信息做一些统计。基础的类型是球员包含其基本信息和技术统计，如下：

public class Player {
    private final String firstName;
    private final String lastName;
    private final String community;

    private final int points;
    private final int rebounds;
    private final float fieldGoal;

    @Override
    public String toString() {
        return "'" + firstName +
                ", " + lastName + '\'' +
                ", from '" + community + '\'' +
                ", scores=" + points +
                ", rebounds=" + rebounds +
                String.format(", fieldGoal=%.2f%%", fieldGoal * 100.f);
    }

    private Player(String firstName, String lastName, String community, int scores, int rebounds, float fieldGoal) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.community = community;
        this.points = scores;
        this.rebounds = rebounds;
        this.fieldGoal = fieldGoal;
    }

    public static class Builder {
        private String firstName;
        private String lastName;
        private String community;
        private int scores;
        private int  rebounds;
        private float fieldGoal;

        public Builder firstName(String firstName) {
            this.firstName = firstName;
            return this;
        }

        public Builder lastName(String lastName) {
            this.lastName = lastName;
            return this;
        }

        public Builder community(Supplier<String> communitySupplier) {
            community = communitySupplier.get();
            return this;
        }

        public Builder points(Supplier<Integer> pointsSupplier) {
            scores = pointsSupplier.get();
            return this;
        }

        public Builder rebounds(Supplier<Integer> reboundsSupplier) {
            rebounds = reboundsSupplier.get();
            return this;
        }

        public Builder fieldGoal(Supplier<Float> fgSupplier) {
            fieldGoal = fgSupplier.get();
            return this;
        }

        public Player build() {
            return new Player(firstName, lastName, community, scores, rebounds, fieldGoal);
        }
    }
}

再有就是球队了，就是针对球员们的操作的地方，首先，需要生成数据：

public class Brooklyn {
    public static void main(String[] args) {
        List<Player> players = generatePlayers();
    }

    private static List<Player> generatePlayers() {
        List<String> names = List.of(
                "James Harden", "Kevin Durant", "Kyrie Irving", "Nic Clyxton",
                "Kessler Edwards", "Bruce Brown", "LaMarcus Aldridge", "Blake Griffin"
        );
        List<String> communities = List.of("The Bronx", "Brooklyn", "Manhattan", "Queens", "Staten Island");
        Random random = new Random(System.currentTimeMillis());

        return names.stream()
                .map(name -> {
                    String[] parts = name.split(" ");
                    return new Player.Builder().firstName(parts[0])
                            .lastName(parts[1])
                            .community(() -> {
                                int index = random.nextInt(communities.size());
                                return communities.get(index);
                            })
                            .points(() -> random.nextInt(61))
                            .rebounds(() -> random.nextInt(31))
                            .fieldGoal(() -> random.nextFloat())
                            .build();
                })
                .collect(Collectors.toList());
    }
}

这里为了方便使用了一个Builder Pattern。另外，创建数据的过程中，其实用到上面提到的大量知识点，如Supplier的使用，以及闭包和方法引用。整体并不难，可以仔细读一读例子中的代码。

Stream基础操作

先来看一下Stream的基础操作，包括filter，map和reduce，以及sort和match，不准备说太多的废话，将以实例操作为主线来讲解。

forEach

也即遍历，非常方便：

players.forEach(System.out::println);

输出会是：

‘James, Harden’, from ‘Brooklyn’, scores=11, rebounds=24, fieldGoal=10.62%

‘Kevin, Durant’, from ‘Queens’, scores=48, rebounds=4, fieldGoal=47.16%

‘Kyrie, Irving’, from ‘Staten Island’, scores=17, rebounds=21, fieldGoal=86.05%

‘Nic, Clyxton’, from ‘Queens’, scores=43, rebounds=11, fieldGoal=99.66%

‘Kessler, Edwards’, from ‘The Bronx’, scores=55, rebounds=12, fieldGoal=46.78%

‘Bruce, Brown’, from ‘Queens’, scores=10, rebounds=20, fieldGoal=77.51%

‘LaMarcus, Aldridge’, from ‘Manhattan’, scores=35, rebounds=22, fieldGoal=98.18%

‘Blake, Griffin’, from ‘Brooklyn’, scores=3, rebounds=4, fieldGoal=38.06%

这个使用起来相当简单，forEach接收一个Consumer，另外需要注意的是forEach不会返回一个Stream对象，所以不能在其后再继续添加链了。它通常作为整个链路的终端，消费最终结果。

注意：因为数据生成过程中使用了一些随机数，所以运行结果可能会不同。

filter

想看看哪些球员，命中率超过五成：

       players.stream()
                .filter(player -> player.getFieldGoal() >= 0.5f)
                .forEach(System.out::println);

输出：

‘James, Harden’, from ‘Brooklyn’, scores=6, rebounds=22, fieldGoal=95.02%

‘Kevin, Durant’, from ‘The Bronx’, scores=37, rebounds=17, fieldGoal=78.81%

‘Bruce, Brown’, from ‘Queens’, scores=26, rebounds=23, fieldGoal=57.35%

‘LaMarcus, Aldridge’, from ‘The Bronx’, scores=35, rebounds=4, fieldGoal=59.75%

filter还是很容易理解的，它接收一个Predict，然后返回Stream中符合条件的元素，也即Predict中是true的。

map

转换，把一种数据类型转换为另外一种类型，其实从创建数据的方法generatePlayers中就可以看到了，是把String转换为Player，根据名字生成数据对象。

sort

接着前面的例子，把输出按命中率从高到低排个序吧：

    players.stream()
                .filter(player -> player.getFieldGoal() >= 0.5f)
                .sorted((a, b) -> (int) (b.getFieldGoal()*100 - a.getFieldGoal()*100))
                .forEach(System.out::println);

输出：

‘Nic, Clyxton’, from ‘Queens’, scores=34, rebounds=17, fieldGoal=93.82%

‘Kyrie, Irving’, from ‘Brooklyn’, scores=37, rebounds=16, fieldGoal=82.95%

‘LaMarcus, Aldridge’, from ‘Staten Island’, scores=43, rebounds=10, fieldGoal=52.94%

flatMap

map是把一种数据类型转换为另外一各类型，然后让其在链式中流动，flatMap是更为复杂的操作，它是先做map再做flat，想当于把二维的Stream展平成为一维的Stream，传给flatMap的lambda必须返回一个Stream，来看个例子：

     public static Stream<String> queryEmail(String name) {
         return Stream.of(name + "@brooklyn.nets");
     }

     players.stream()
            .flatMap(player -> queryEmail(player.getLastName()))
            .forEach(System.out::println);

输出：

[email protected]

[email protected]

[email protected]

[email protected]

[email protected]

[email protected]

[email protected]

[email protected]

这里的获取到的Email是另外一个Stream，所以这里必须用flatMap，也即当把player转换为Email后，必须要再flat，变成最初的链中的对象。

及时求值

前面讲的操作都是惰性求值的，它们都是返回一个Stream，而Stream本身仅是封装操作，其实并没有生成最终值。但有些操作是可以生成最终值的，就是把整个链路的值进行运算，然后生成最终的值，但这个值不再是Stream了，也就是说及时求值操作只能作为链式的终点。

注意：惰性求值是函数式编程的一个概念，它的主要目的是将行为与结果分离开来，以方便并行化处理。具体可以参阅《函数式编程思维》书中的第4章，有详细的论述。

count

计算一下来自『Queens』的球员数量：

        long fromQueens = players.stream()
                .filter(player -> player.getCommunity().equals("Queens"))
                .count();
        System.out.println(fromQueens);
        // Output is: 2

match

查看Stream的元素中是否有匹配的条件的，有any意即任意元素有了匹配，all所有，none没有（相当于not all）：

        boolean fromQueens = players.stream()
                .anyMatch(player -> player.getCommunity().equals("Queens"));
        System.out.println(fromQueens);
        // 是否有人来自于Queens，true
        boolean fromQueens = players.stream()
                .allMatch(player -> player.getCommunity().equals("Queens"));
        System.out.println(fromQueens);
        // 所有人都来自Queens，false
        boolean fromQueens = players.stream()
                .noneMatch(player -> player.getCommunity().equals("Queens"));
        System.out.println(fromQueens);
        // 所有人都来自非Queens，false

reduce

折叠或者叫作化约，有些语言也称之为fold，它接收两个参数，第一个是初始值，然后是一个二元操作符BinaryOperator，二元操作的第一个参数是截止目前的结果，第二个参数是当前的元素，然后针对每个元素进行滚动执行这个二元操作符。这么说有点难于理解，我们来个，计算球员们的总得分吧：

        int totalPoints = players.stream()
                .map(Player::getPoints)
                .reduce(0, (a, b) -> a + b);
        System.out.println(totalPoints);
        // output is 247

再来计算平均命中率：

        Optional<Float> averageFieldGoal = players.stream()
                .map(Player::getFieldGoal)
                .reduce((a, b) -> (a + b) / 2.f);
        System.out.println(averageFieldGoal.get());
        // Output is 0.40

如果没有初始值，或者初始值是0（针对数值时），为空时（针对对象），那么可以省略reduce的第1个参数，这时它会用第1个元素用作初始值。

max和min

寻找最少的篮板数的球员：

        Optional<Player> minRebound = players.stream()
                        .min((a, b) -> a.getRebounds() - b.getRebounds());
        System.out.println(minRebound.get());

输出：

‘Kessler, Edwards’, from ‘Staten Island’, scores=8, rebounds=2, fieldGoal=97.53%

寻找命中率最高的球员：

        Optional<Player> bestShooter = players.stream()
                        .max((a, b) -> (int) (a.getFieldGoal()*100f - b.getFieldGoal()*100f));
        System.out.println(bestShooter.get());

输出：

‘Bruce, Brown’, from ‘The Bronx’, scores=25, rebounds=15, fieldGoal=88.19%

注意：reduce无初始值时，max和min返回的都是Optional，因为可能会取不到具体的值。

This is just the beginning

学无止境，Stream API还有很多高级的工具，以及Java 8的新特性也还有很多，还有待后面继续深入学习。

Android SDK的支持情况

进入智能手机时代和移动互联网时代，Java曾一度没落，好在安卓的官方开发语言是Java，这也让Java没有被丢弃，虽然现在谷歌力推Kotlin，不过Java仍是安卓 开发的首选语言，且仍在被广泛使用。不过，安卓的Java，并不是Oracle的Java SE，而是基于Apache开源的OpenJDK，这货自Java 1.6版本以后就没怎么更新，而作为downstream的安卓，更是一直停留在1.6的版本上面，这也导致了安卓开发人猿一直未能跟紧Java的发展，当然 这也是Kotlin自推出以来大受安卓开发人猿欢迎的原因。好在谷歌也在推进，它是以打包插件的方式来支持Java 7和Java 8的部分子集。现在AGP（Android Gradle Plugin）4.0以上的版本，是可以使用大部分Java 8的特性的，前面讲述的lambda，Optional，函数接口和Stream等都是可以直接使用的，只要把AGP的版本升级到4.0以上，sourceCompatibility选择VERSION_1_8，就可以了。

可以参阅官方文档。而这篇文章相当不错的阐述一些详细的原因，可以仔细读一下。

优质书籍

编程范式的学习曲线都是非常陡峭的，函数式编程注重的是行为的抽象，以行为（函数）为第一要素来构建解决方案，这需要思维的转变。并不是说你用了一个lambda就是函数式编程了。因此需要系统化的学习。而系统化的学习，最好的方式就是去啃书（没说看，是要啃书）。

下面列出关于函数式编程，特别是用Java 8进行实践函数式编程的几本非优质的书籍：

Functional Thinking

中译名是《函数式编程思维》，是由Neal Ford出品的佳作，专门讲述如何Thinking in Functional Programming。这本书也不是很厚，非常值得看。因为是重点讲解函数式编程思维 的，所以它用了Java/Scala和Groovy，并且Java的版本还不是Java 8的。

这里也要说一下，编程范式跟语言是否直接支持没有关系，它更是一种思维抽象方法，比如用C也能写出完全符合面向对象的代码；用Java 7以前的版本也能写出函数式程序。

Java 8 Lambdas: Functional Programming For The Masses

中译名是《Java 8函数式编程》，由Richard Warburton写的。里面有丰富的实例和练习题，也不厚，专注于讲解如何用Java 8来实践函数式编程。

Java 8 in Action

中译名《Java 8实战》，由三位作者Raoul-Gabriel Urma, Mario Fusco, and Alan Mycroft合著。内容其实与前面那个差不多，但略有不同，这本书是重点讲解Java 8的新特性的，当然大量篇幅也是讲用Java 8实践函数式编程的（因为Java 8最重要的改进就是对函数式编程的支持），但还有其他的内容。并且这本书较厚，里面各种知识点讲解比较详细。

参考资料

• A Guide to Java Streams in Java 8: In-Depth Tutorial With Examples
• Java8 新特性教程
• [译] 一文带你玩转 Java8 Stream 流，从此操作集合 So Easy
• Java8 Stream完全使用指南
• The Java 8 Stream API Tutorial