一、Java8流的引入

对于Java的开发者来说，Java集合的使用是再熟悉不过了。几乎每个Java应用里面都或多或少的会制造和处理集合。但在Java8之前对于集合的操作并不是那么的完美，许多时候你需要书写很多的重复代码来实现对集合的操作，所以Java8引用了流的概念来帮你更优雅的处理集合。

二、流是什么

流是Java API的新成员，它允许你以声明性方式处理数据集合（通过查询语句来表达，而不
是临时编写一个实现）。此外，流还可以透明地并行处理，你无需写任何多线程代码了。（引用《Java8实战》）
此处以Phone类作为通用的模型，来进行说明。

public class Phone {

    private final String version; //手机型号

    private final String manufacturer; //制造厂商

    private final int price; //价格

    private final boolean isSupport5G; //是否支持5G

    private final Type type;  //手机目标人群

    public Phone(String version, String manufacturer, int price, boolean isSupport5G, Type type) {
        this.version = version;
        this.manufacturer = manufacturer;
        this.price = price;
        this.isSupport5G = isSupport5G;
        this.type = type;
    }

    public String getManufacturer() {
        return manufacturer;
    }

    public int getPrice() {
        return price;
    }

    public boolean isSupport5G() {
        return isSupport5G;
    }

    public Type getType() {
        return type;
    }

    public String getVersion() {
        return version;
    }

    //手机适合的人群类型
    public enum Type{
        BUSINESSMAN, //商务人士

        TEENAGES,  //青年

        OLDPEOPLE,  //老年人

        PUBLICPEOPLE,  //大众
    }

}

假设你需要找出价格低于2000的手机的手机型号，并按照价格进行排序：
（1）使用Java7：

 List<Phone> priceLessThan2000 = new ArrayList<>();
        for(Phone phone : Data.phones){
            if (phone.getPrice() < 2000) {
                priceLessThan2000.add(phone);
            }
        }
        
 Collections.sort(priceLessThan2000, new Comparator<Phone>() {
            @Override
            public int compare(Phone o1, Phone o2) {
                return Integer.compare(o1.getPrice(),o2.getPrice());
            }
        });
List<String> versions = new ArrayList<>();
        for(Phone phone : priceLessThan2000){
            versions.add(phone.getVersion());
        }

（2）使用Java8：

        List<String> priceLessThan2000Names_By8 = Data.phones.stream()
                .filter(d -> d.getPrice() < 2000)
                .sorted(Comparator.comparing(Phone::getPrice))
                .map(Phone::getVersion)
                .collect(toList());

使用Java8来实现的代码与Java7有很大区别：
1、代码以声明式方式写的：直接说明了这段代码想要完成什么功能，而不是如何实现一个操作（利用循环和if等控制语句）
2、通过把几个基础操作连接起来，来说明复杂的数据处理流水线。filter结果传给sorted方法，再传map方法，最后传collect

三、流简介

从集合入手来了解流，Java 8中的集合支持一个新的stream方法，它会返回一个流（接口定义在java.util.stream.Stream里）。
流到底是什么？（以下引用《Java8实战》）简短的定义就是“从支持数据处理操作的源生成的元素序列”。
（1）元素序列——就像集合一样，流也提供了一个接口，可以访问特定元素类型的一组有序
值。因为集合是数据结构，所以它的主要目的是以特定的时间/空间复杂度存储和访问元素（如ArrayList 与 LinkedList）。但流的目的在于表达计算，集合讲的是数据，流讲的是计算。

（2）源——流会使用一个提供数据的源，如集合、数组或输入/输出资源。 请注意，从有序集合生成流时会保留原有的顺序。由列表生成的流，其元素顺序与列表一致。

（3）数据处理操作——流的数据处理功能支持类似于数据库的操作，以及函数式编程语言中
的常用操作，如filter、map、reduce、find、match、sort等。流操作可以顺序执行，也可并行执行。

（4）流水线——很多流操作本身会返回一个流，这样多个操作就可以链接起来，形成一个大
的流水线。流水线的操作可以看作对数据源进行数据库式查询

（5）内部迭代——与使用迭代器显式迭代的集合不同，流的迭代操作是在背后进行的。

看这一段代码：

        List<String> threeHighPhones = Data.phones.stream()//从手机列表里获取流，建立操作流水线
                .filter( d -> d.getPrice() > 2000)//首先选出价钱高于2000的手机
                .map(Phone::getVersion)//获取手机型号
                .limit(3)//只选择头三个
                .collect(toList());//将结果保存在另一个List里面
                

在这个例子中，一开始对phones这个手机集合调用stream方法，得到一个流。数据源是手机列表，它给流提供一个元素序列。接下来，对流应用一系列数据处理操作：filter、map，limit和collect。除了collect之外，所有这些操作都会返回另一个流，这样它们就可以接成一条流水线，于是就可以看作对源的一个查询。最后，collect操作开始处理流水线，并返回结果（它和别的操作不一样，因为它返回的不是流，在这里是一个List）。在调用collect之前，没有任何结果产生，实际上根本就没有从phones里选择元素。你可以这么理解：链中的方法调用都在排队等待，直到调用collect。
下图为整体流的操作顺序：

J1.PNG

（1）filter——接受Lambda，从流中排除某些元素。在本例中，通过传递lambda d -> d.getPrice() > 2000，选择手机价钱高于2000的手机

（2）map——接受一个Lambda，将元素转换成其他形式或提取信息。在本例中，通过传递方法引用Phone::getVersion，相当于Lambda d -> d.getVersion，提取了每部手机的型号

（3）limit——截断流，使其元素不超过给定数量。

（4）collect——将流转换为其他形式。在本例中，流被转换为一个列表。你可以把collect看作能够接受各种方案作为参数，并将流中的元素累积成为一个汇总结果的操作。这里toList()就是将流转换为列表的方案

刚刚这段代码，与逐项处理手机列表的代码有很大不同。首先，我们
使用了声明性的方式来处理手机数据，即你说的对这些数据需要做什么：“查找价格高于2000的三部手机的型号。”你并没有去实现筛选（filter）、提取（map）或截断（limit）功能Streams库已经自带了。因此，Stream API在决定如何优化这条流水线时更为灵活。例如，筛选、提取和截断操作可以一次进行，并在找到这三部手机后立即停止。

只能遍历一次

流只能遍历一次。遍历完之后，我们就说这个流已经被消费掉了。你可以从原始数据源那里再获得一个新的流来重新遍历一遍，就像迭代器一样。例如，以下代码会抛出一个异常，说流已被消费掉了：

        List<String> title = Arrays.asList("1","2","3");
        Stream<String> stringStream = title.stream();
        stringStream.forEach(System.out::println);
        stringStream.forEach(System.out::println);  //抛出错误，java.lang.IllegalStateException:流已被操作或关闭

外部迭代与内部迭代

集合和流的另一个关键区别在于它们遍历数据的方式。

使用Collection接口需要用户去做迭代（比如用for-each），这称为外部迭代。 相反，Streams库使用内部迭代——它帮你把迭代做了，还把得到的流值存在了某个地方，你只要给出一个函数说要干什么就可以了

集合：用for-each循环外部迭代：

List<String> names = new ArrayList<>();
        for(Phone phone : Data.phones){//显示迭代手机列表
            names.add(phone.getVersion());//把型号添加进集合
        }

流：内部迭代：

        List<String> names_ = Data.phones.stream()
                .map(Phone::getVersion)
                .collect(toList());

内部迭代与外部迭代（来自《Java8实战》）：

J2.PNG

流操作

Stream接口定义了许多操作。它们可以分为两大类。
（1）filter、map和limit可以连成一条流水线
（2）collect触发流水线执行并关闭它
可以连接起来的流操作称为中间操作，关闭流的操作称为终端操作

中间操作

等中间操作会返回另一个流。这让多个操作可以连接起来形成一个查
询。重要的是，除非流水线上触发一个终端操作，否则中间操作不会执行任何处理——它们很懒。这是因为中间操作一般都可以合并起来，在终端操作时一次性全部处理（引自《Java8实战》）

看这段代码：

        List<String> names = Data.phones.stream()
                .filter(d -> {
                    System.out.println("Filtering  : " + d.getVersion());
                    return d.getPrice() < 2000;
                })
                .map(d -> {
                    System.out.println("Maping  : " + d.getVersion());
                    return d.getVersion();
                })
                .limit(3)
                .collect(Collectors.toList());

执行后打印：

Filtering  : 红米7
Maping  : 红米7
Filtering  : 小米8
Filtering  : 魅蓝6
Maping  : 魅蓝6
Filtering  : 诺基亚N9
Maping  : 诺基亚N9
[红米7, 魅蓝6, 诺基亚N9]

（1）只选出了前三个符合条件的手机型号！
（2）filter和map是两个独立的操作，但它们合并到同一次遍历中了。

终端操作

终端操作会从流的流水线生成结果。其结果是任何不是流的值，比如List、Integer，甚
至void。

如：在下面的流水线中，forEach是一个返回void的终端操作，它会对源中的每道
菜应用一个Lambda。

Data.phones.stream().forEach(System.out::println);

使用流

筛选和切片

用谓词筛选

Streams接口支持filter方法。该操作会接受一个谓词（一个返回boolean的函数）作为参数，并返回一个包括所有符合谓词的元素的流。

filter方法源码：

 /**
     * Returns a stream consisting of the elements of this stream that match
     * the given predicate.
     *
     * <p>This is an <a href="package-summary.html#StreamOps">intermediate
     * operation</a>.
     *
     * @param predicate a <a href="package-summary.html#NonInterference">non-interfering</a>,
     *                  <a href="package-summary.html#Statelessness">stateless</a>
     *                  predicate to apply to each element to determine if it
     *                  should be included
     * @return the new stream
     */
    Stream<T> filter(Predicate<? super T> predicate);

Predicate的意思是：谓语。该方法会返回一个新的对应的流，该流包含了与所给谓语匹配的元素，该操作是一个中间操作（intermediate operation）。

从手机列表中筛选支持5G的手机：

        List<Phone> phoneSupported5G = Data.phones.stream()
                .filter(Phone::isSupport5G)
                .collect(Collectors.toList());

筛选各异的元素

流还支持一个叫作distinct的方法，它会返回一个元素各异（根据流所生成元素的hashCode和equals方法实现）的流

distinct方法源码：

 /**
     * Returns a stream consisting of the distinct elements (according to
     * {@link Object#equals(Object)}) of this stream.
     *
     * <p>For ordered streams, the selection of distinct elements is stable
     * (for duplicated elements, the element appearing first in the encounter
     * order is preserved.)  For unordered streams, no stability guarantees
     * are made.
     *
     * <p>This is a <a href="package-summary.html#StreamOps">stateful
     * intermediate operation</a>.
     *
     * @apiNote
     * Preserving stability for {@code distinct()} in parallel pipelines is
     * relatively expensive (requires that the operation act as a full barrier,
     * with substantial buffering overhead), and stability is often not needed.
     * Using an unordered stream source (such as {@link #generate(Supplier)})
     * or removing the ordering constraint with {@link #unordered()} may result
     * in significantly more efficient execution for {@code distinct()} in parallel
     * pipelines, if the semantics of your situation permit.  If consistency
     * with encounter order is required, and you are experiencing poor performance
     * or memory utilization with {@code distinct()} in parallel pipelines,
     * switching to sequential execution with {@link #sequential()} may improve
     * performance.
     *
     * @return the new stream
     */
    Stream<T> distinct();

该方法属于中间操作，会返回一个新的流，包含了独一无二的元素。

以下代码筛选出列表中所有的偶数，并确保没有重复。

        List<Integer> numbers = Arrays.asList(1,2,5,9,4,4,8,9,5);
        numbers.stream()
                .filter( i -> i % 2 == 0)
                .distinct()
                .forEach(System.out::println);

截短流

流支持limit(n)方法，该方法会返回一个不超过给定长度的流。所需的长度作为参数传递
给limit。如果流是有序的，则最多会返回前n个元素

limit方法源码：

/**
     * Returns a stream consisting of the elements of this stream, truncated
     * to be no longer than {@code maxSize} in length.
     *
     * <p>This is a <a href="package-summary.html#StreamOps">short-circuiting
     * stateful intermediate operation</a>.
     *
     * @apiNote
     * While {@code limit()} is generally a cheap operation on sequential
     * stream pipelines, it can be quite expensive on ordered parallel pipelines,
     * especially for large values of {@code maxSize}, since {@code limit(n)}
     * is constrained to return not just any <em>n</em> elements, but the
     * <em>first n</em> elements in the encounter order.  Using an unordered
     * stream source (such as {@link #generate(Supplier)}) or removing the
     * ordering constraint with {@link #unordered()} may result in significant
     * speedups of {@code limit()} in parallel pipelines, if the semantics of
     * your situation permit.  If consistency with encounter order is required,
     * and you are experiencing poor performance or memory utilization with
     * {@code limit()} in parallel pipelines, switching to sequential execution
     * with {@link #sequential()} may improve performance.
     *
     * @param maxSize the number of elements the stream should be limited to
     * @return the new stream
     * @throws IllegalArgumentException if {@code maxSize} is negative
     */
    Stream<T> limit(long maxSize);

该方法属于中间操作，会返回一个新的流，里面包含的元素的个数不会超过所给参数的大小。

找出前三个价格高于2000的手机：

        List<Phone> phones = Data.phones.stream()
                .filter( d -> d.getPrice() > 2000)
                .limit(3)
                .collect(Collectors.toList());

跳过元素

流还支持skip(n)方法，返回一个扔掉了前n个元素的流。如果流中元素不足n个，则返回一
个空流

skip方法源码：

    /**
     * Returns a stream consisting of the remaining elements of this stream
     * after discarding the first {@code n} elements of the stream.
     * If this stream contains fewer than {@code n} elements then an
     * empty stream will be returned.
     *
     * <p>This is a <a href="package-summary.html#StreamOps">stateful
     * intermediate operation</a>.
     *
     * @apiNote
     * While {@code skip()} is generally a cheap operation on sequential
     * stream pipelines, it can be quite expensive on ordered parallel pipelines,
     * especially for large values of {@code n}, since {@code skip(n)}
     * is constrained to skip not just any <em>n</em> elements, but the
     * <em>first n</em> elements in the encounter order.  Using an unordered
     * stream source (such as {@link #generate(Supplier)}) or removing the
     * ordering constraint with {@link #unordered()} may result in significant
     * speedups of {@code skip()} in parallel pipelines, if the semantics of
     * your situation permit.  If consistency with encounter order is required,
     * and you are experiencing poor performance or memory utilization with
     * {@code skip()} in parallel pipelines, switching to sequential execution
     * with {@link #sequential()} may improve performance.
     *
     * @param n the number of leading elements to skip
     * @return the new stream
     * @throws IllegalArgumentException if {@code n} is negative
     */
    Stream<T> skip(long n);

该方法属于中间操作，它会返回全新的流，这个流会把前n个元素去除掉，如果原来的流中元素个数不足n个，则返回一个空的流。

先选出价格高于2000的手机，然后跳过前两个

        List<Phone> phones_skip = Data.phones.stream()
                .filter( d -> d.getPrice() > 2000)
                .skip(2)
                .collect(Collectors.toList());

映射

对流中每一个元素应用函数

流支持map方法，它会接受一个函数作为参数。这个函数会被应用到每个元素上，并将其映射成一个新的元素（使用映射一词，是因为它和转换类似，但其中的细微差别在于它是“创建一个新版本”而不是去“修改”）（引自《Java8实战》）

以下代码用于提取手机的型号：

        List<String> names = Data.phones.stream()
                .map(Phone::getVersion)
                .collect(Collectors.toList());

因为getVersion方法返回一个String，所以map方法输出的流的类型就是Stream<String>。

map方法源码：

    /**
     * Returns a stream consisting of the results of applying the given
     * function to the elements of this stream.
     *
     * <p>This is an <a href="package-summary.html#StreamOps">intermediate
     * operation</a>.
     *
     * @param <R> The element type of the new stream
     * @param mapper a <a href="package-summary.html#NonInterference">non-interfering</a>,
     *               <a href="package-summary.html#Statelessness">stateless</a>
     *               function to apply to each element
     * @return the new stream
     */
    <R> Stream<R> map(Function<? super T, ? extends R> mapper);

该方法是一个中间操作，返回一个新的流，该流包含了使用参数中所给函数之后得到的结果。

流的扁平化

假设对于一个单词字符串的集合，想要找出各不相同的字符。（例子来源于《Java8实战》）

Version1：

        words.stream()
                .map(word -> word.split(""))
                .distinct()
                .collect(Collectors.toList());

这个方法的问题在于，传递给map方法的Lambda为每个单词返回了一个String[]（String
列表）。因此，map返回的流实际上是Stream<String[]>类型的。你真正想要的是用
Stream<String>来表示一个字符流

尝试解决：
使用map和Arrays.stream()：
首先，你需要一个字符流，而不是数组流。有一个叫作Arrays.stream()的方法可以接受
一个数组并产生一个流，如：

String[] arrayOfWords = {"Goodbye", "World"}; 
Stream<String> streamOfwords = Arrays.stream(arrayOfWords);

按照前面例子实现：

words.stream() 
 .map(word -> word.split("")) 
 .map(Arrays::stream) 
 .distinct() 
 .collect(toList());

当前的解决方案仍然搞不定！这是因为，你现在得到的是一个流的列表（更准确地说是
Stream<String>），而最终需要的是List<String>

最终方案（使用flatMap）：

List<String> uniqueCharacters = 
 words.stream() 
 .map(w -> w.split("")) 
 .flatMap(Arrays::stream) 
 .distinct() 
 .collect(Collectors.toList());

使用flatMap方法的效果是，各个数组并不是分别映射成一个流，而是映射成流的内容。所
有使用map(Arrays::stream)时生成的单个流都被合并起来，即扁平化为一个流

总之，flatmap方法让你把一个流中的每个值都换成另一个流，然后把所有的流连接
起来成为一个流。

查找和匹配

检查谓词是否至少匹配一个元素

比如可以用来查找手机列表里面是否有手机支持5G：

if (Data.phones.stream()
        .anyMatch(Phone::isSupport5G)) {
            System.out.println("有手机支持5G");
        }

anyMatch方法源码：

    /**
     * Returns whether any elements of this stream match the provided
     * predicate.  May not evaluate the predicate on all elements if not
     * necessary for determining the result.  If the stream is empty then
     * {@code false} is returned and the predicate is not evaluated.
     *
     * <p>This is a <a href="package-summary.html#StreamOps">short-circuiting
     * terminal operation</a>.
     *
     * @apiNote
     * This method evaluates the <em>existential quantification</em> of the
     * predicate over the elements of the stream (for some x P(x)).
     *
     * @param predicate a <a href="package-summary.html#NonInterference">non-interfering</a>,
     *                  <a href="package-summary.html#Statelessness">stateless</a>
     *                  predicate to apply to elements of this stream
     * @return {@code true} if any elements of the stream match the provided
     * predicate, otherwise {@code false}
     */
    boolean anyMatch(Predicate<? super T> predicate);

该方法是一个终端操作，返回一个布尔值。如果流里面有任何一个元素能够匹配的所给参数谓语，那么就返回true；否则返回false。

检查谓词是否匹配所有元素

以下代码如果手机列表中的手机都支持5G则打印输出：

        if(Data.phones.stream()
        .allMatch(Phone::isSupport5G)){
            System.out.println("都支持5G");
        }

allMatch方法源码：

    /**
     * Returns whether all elements of this stream match the provided predicate.
     * May not evaluate the predicate on all elements if not necessary for
     * determining the result.  If the stream is empty then {@code true} is
     * returned and the predicate is not evaluated.
     *
     * <p>This is a <a href="package-summary.html#StreamOps">short-circuiting
     * terminal operation</a>.
     *
     * @apiNote
     * This method evaluates the <em>universal quantification</em> of the
     * predicate over the elements of the stream (for all x P(x)).  If the
     * stream is empty, the quantification is said to be <em>vacuously
     * satisfied</em> and is always {@code true} (regardless of P(x)).
     *
     * @param predicate a <a href="package-summary.html#NonInterference">non-interfering</a>,
     *                  <a href="package-summary.html#Statelessness">stateless</a>
     *                  predicate to apply to elements of this stream
     * @return {@code true} if either all elements of the stream match the
     * provided predicate or the stream is empty, otherwise {@code false}
     */
    boolean allMatch(Predicate<? super T> predicate);

该方法是一个终端操作，返回布尔值。如果流中所有元素都匹配所给谓语，那么返回true；否则返回false。

查找元素

findAny方法将返回当前流中的任意元素。它可以与其他流操作结合使用。

以下代码在手机列表中查找支持5G的手机：

        Optional<Phone> phone = Data.phones.stream()
                .filter(Phone::isSupport5G)
                .findAny();

findAny方法源码：

    /**
     * Returns an {@link Optional} describing some element of the stream, or an
     * empty {@code Optional} if the stream is empty.
     *
     * <p>This is a <a href="package-summary.html#StreamOps">short-circuiting
     * terminal operation</a>.
     *
     * <p>The behavior of this operation is explicitly nondeterministic; it is
     * free to select any element in the stream.  This is to allow for maximal
     * performance in parallel operations; the cost is that multiple invocations
     * on the same source may not return the same result.  (If a stable result
     * is desired, use {@link #findFirst()} instead.)
     *
     * @return an {@code Optional} describing some element of this stream, or an
     * empty {@code Optional} if the stream is empty
     * @throws NullPointerException if the element selected is null
     * @see #findFirst()
     */
    Optional<T> findAny();

该方法是一个终端操作，返回一个Optional类，里面包含了一些符合前面流操作之后的元素。或者返回一个空的Optional类，如果流是空的话。

查找第一个元素

有些流有一个出现顺序（encounter order）来指定流中项目出现的逻辑顺序（比如由List或排序好的数据列生成的流）。对于这种流，如果想要找到第一个元素，你可以使用findFirst方法。

以下代码能找出第一个平方能被3整除的数：

        List<Integer> someNums = Arrays.asList(1,2,3,4,5,6,7,8,9);
        Optional<Integer> f = someNums.stream()
                .map( x -> x * x)
                .filter( x -> x % 3 == 0)
                .findFirst();

findFirst方法源码：

    /**
     * Returns an {@link Optional} describing the first element of this stream,
     * or an empty {@code Optional} if the stream is empty.  If the stream has
     * no encounter order, then any element may be returned.
     *
     * <p>This is a <a href="package-summary.html#StreamOps">short-circuiting
     * terminal operation</a>.
     *
     * @return an {@code Optional} describing the first element of this stream,
     * or an empty {@code Optional} if the stream is empty
     * @throws NullPointerException if the element selected is null
     */
    Optional<T> findFirst();

该方法是一个终端操作，返回一个Optional类，里面包含前面流操作之后的第一个元素；或者返回一个空的Optional类，如果流是空的话。

归约

将流中所有元素反复结合起来，得到一个值，比如一个Integer。这样的查询可以被归类为归约操作
（将流归约成一个值）。（引自《Java8实战》）

元素求和

（1）for-each循环版本：

int sum = 0; 
for (int x : numbers) { 
  sum += x; 
}

（Java8版本）：

        List<Integer> nums = Arrays.asList(1,2,3,4,5,6,7,8,9);
        int sum = nums.stream()
                .reduce(0,(x,y) -> x + y);

reduce方法源码：

    /**
     * Performs a <a href="package-summary.html#Reduction">reduction</a> on the
     * elements of this stream, using the provided identity value and an
     * <a href="package-summary.html#Associativity">associative</a>
     * accumulation function, and returns the reduced value.  This is equivalent
     * to:
     * <pre>{@code
     *     T result = identity;
     *     for (T element : this stream)
     *         result = accumulator.apply(result, element)
     *     return result;
     * }</pre>
     *
     * but is not constrained to execute sequentially.
     *
     * <p>The {@code identity} value must be an identity for the accumulator
     * function. This means that for all {@code t},
     * {@code accumulator.apply(identity, t)} is equal to {@code t}.
     * The {@code accumulator} function must be an
     * <a href="package-summary.html#Associativity">associative</a> function.
     *
     * <p>This is a <a href="package-summary.html#StreamOps">terminal
     * operation</a>.
     *
     * @apiNote Sum, min, max, average, and string concatenation are all special
     * cases of reduction. Summing a stream of numbers can be expressed as:
     *
     * <pre>{@code
     *     Integer sum = integers.reduce(0, (a, b) -> a+b);
     * }</pre>
     *
     * or:
     *
     * <pre>{@code
     *     Integer sum = integers.reduce(0, Integer::sum);
     * }</pre>
     *
     * <p>While this may seem a more roundabout way to perform an aggregation
     * compared to simply mutating a running total in a loop, reduction
     * operations parallelize more gracefully, without needing additional
     * synchronization and with greatly reduced risk of data races.
     *
     * @param identity the identity value for the accumulating function
     * @param accumulator an <a href="package-summary.html#Associativity">associative</a>,
     *                    <a href="package-summary.html#NonInterference">non-interfering</a>,
     *                    <a href="package-summary.html#Statelessness">stateless</a>
     *                    function for combining two values
     * @return the result of the reduction
     */
    T reduce(T identity, BinaryOperator<T> accumulator);

该方法是一个终端操作，方法接受两个参数：
（1）第一个是初始值
（2）第二个是BinaryOperator，它对两个相同类型的操作数进行操作，返回一个操作之后的相同类型的结果。

使用方法引用让这段代码更简洁：

        int sums = nums.stream()
                .reduce(0,Integer::sum);

计算流中的最大值：

        Optional<Integer> max = nums.stream()
                .reduce(Integer::max);