Java8特性-Stream用法总结

Java 8 中的 Stream 是对集合（Collection）对象功能的增强，它专注于对集合对象进行各种非常便利、高效的聚合操作（aggregate operation），或者大批量数据操作 (bulk data operation)。 Stream API 借助于同样新出现的 Lambda 表达式，极大的提高编程效率和程序可读性。同时它提供串行和并行两种模式进行汇聚操作，并发模式能够充分利用多核处理器的优势，使用 java7 引入的 fork/join 并行方式来拆分任务和加速处理过程。通常编写并行代码很难而且容易出错, 但使用 Stream API 无需编写一行多线程的代码，就可以很方便地写出高性能的并发程序。

在深入了解流之前，我们先了解 Stream 中几个常用的函数式接口：

函数名	入参类型	返回类型	接口描述
Predicate	T	boolean	判断入参是否符合要求，用于流元素的匹配和过滤
Function	T	R	将T对象转换成R对象返回，用于流元素类型转换
Comparator	(T, T)	int	比较传入的两个对象，用于流元素排序，求极值
Consumer	T	void	消费流元素，用于流元素的聚合和遍历操作
Supplier	None	T	生产流元素，根据提供的Supplier生成无限流
BinaryOperator	(T, T)	T	传入两个同类型对象返回一个同类型对象，用于reduce操作
UnaryOperator	T	T	传入一个对象返回一个同类型对象，用于iterate操作

1. 如何创建 Stream

所有流的基类是 BaseStream，主要子类有 Stream（最常用的流），IntStream（Int型流），DoubleStream（Double型流），LongStream（Long型流），创建流有很多种方式，总结如下：

1.1 collection 生成流方法

常用的 Collection 子类有 List、Set、Queue（单向队列）、Deque（双向队列）,Collection 类有两个生成流的方法：
1）生成串行流方法：stream()

default Stream stream() {
        return StreamSupport.stream(spliterator(), false);
}

2）生成并行流方法：parallelStream()

default Stream parallelStream() {
        return StreamSupport.stream(spliterator(), true);
}

Collection 的子类可以直接调用这两个方法来生成适合的流，一般如果是基本类型的流类型，建议直接使用串行流来进行数据操作。
示例：

// 获取字符串集合的串行流
List strList = new ArrayList<>();
Stream stream = strList.stream();

// 获取实体类集合的并行流
List persons = new ArrayList<>();
Stream stream2 = persons.parallelStream();
Stream stream = strList.stream().parallel();

1.2 Array 生成流方法

使用 Arrays 的静态方法生成流：

String [] strArray = {"aa", "bb"};
Stream stream = Arrays.stream(strArray);

1.3 使用 Stream 类的方法

Stream 类可以直接使用原生方法来生成各种流，也可以通过构建器来进行构建，用法如下：
1）of() 方法:
通过传入一个实体或者实体数组来生成对应的流：

// 传入一个实体
public static Stream of(T t) {
    return StreamSupport.stream(new Streams.StreamBuilderImpl<>(t), false);
}

// 传入一个实体数组
@SafeVarargs
@SuppressWarnings("varargs") // Creating a stream from an array is safe
public static Stream of(T... values) {
    return Arrays.stream(values);
}

示例:

List strs = new ArrayList(){
            {
                add("aaa");
                add("bbb");
                add("ccc");
            }
};
Stream> strs1 = Stream.of(strs);

// 注意上边返回的并不是Stream类型的流，下边的构造方式更为常用
Stream aaa = Stream.of("aaa", "bbb", "ccc");

2）通过 generate() 和 iterate() 生成无限流
generate() 方法通过通过一个 supplier 来生成无限流，supplier 定义一个生成规则，比方说生成随机数：Math.random() ，或者直接返回一个字符串：() -> "aa"，由于生成的流是无限流，所以经常跟limit()方法合用，返回前n个数据，示例：

// 生成随机数流，并返回前100条数据
Stream generate1 = Stream.generate(() -> Math.random()).limit(100);

//生成包含100个元素是“aaa”的流
Stream generate = Stream.generate(() -> "aaa").limit(100);

3）使用builder()构建器生成流
Stream类含有一个builder()，该方法返回一个构造器对象，该对象是 Stream类的一个内部类，结构如下：

    /**
     * A mutable builder for a {@code Stream}.  This allows the creation of a
     * {@code Stream} by generating elements individually and adding them to the
     * {@code Builder} (without the copying overhead that comes from using
     * an {@code ArrayList} as a temporary buffer.)
     *
     * 
A stream builder has a lifecycle, which starts in a building
     * phase, during which elements can be added, and then transitions to a built
     * phase, after which elements may not be added.  The built phase begins
     * when the {@link #build()} method is called, which creates an ordered
     * {@code Stream} whose elements are the elements that were added to the stream
     * builder, in the order they were added.
     *
     * @param  the type of stream elements
     * @see Stream#builder()
     * @since 1.8
     */
    public interface Builder extends Consumer {

        /**
         * Adds an element to the stream being built.
         *
         * @throws IllegalStateException if the builder has already transitioned to
         * the built state
         */
        @Override
        void accept(T t);

        /**
         * Adds an element to the stream being built.
         *
         * @implSpec
         * The default implementation behaves as if:
         * 
{@code
         *     accept(t)
         *     return this;
         * }
         *
         * @param t the element to add
         * @return {@code this} builder
         * @throws IllegalStateException if the builder has already transitioned to
         * the built state
         */
        default Builder add(T t) {
            accept(t);
            return this;
        }

        /**
         * Builds the stream, transitioning this builder to the built state.
         * An {@code IllegalStateException} is thrown if there are further attempts
         * to operate on the builder after it has entered the built state.
         *
         * @return the built stream
         * @throws IllegalStateException if the builder has already transitioned to
         * the built state
         */
        Stream build();

    }

使用示例：

// 使用 add() 方法链式添加流元素
Stream