Java8新特性-005-创建Stream

了解 Stream

Java8中有两大最为重要的改变。第一个是 Lambda 表达式；另外一个则是 Stream API(java.util.stream.*)。Stream 是 Java8 中处理集合的关键抽象概念，它可以指定你希望对集合进行的操作，可以执行非常复杂的查找、过滤和映射数据等操作。使用Stream API 对集合数据进行操作，就类似于使用 SQL 执行的数据库查询。也可以使用 Stream API 来并行执行操作。简而言之，Stream API 提供了一种高效且易于使用的处理数据的方式。

---

什么是 Stream

• 流(Stream) 到底是什么呢？是数据渠道，用于操作数据源（集合、数组等）所生成的元素序列。“集合讲的是数据，流讲的是计算！”
• 注意：
  ①Stream 自己不会存储元素。
  ②Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。
  ③Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。

---

Stream 的操作三个步骤

• 创建 Stream
  一个数据源（如：集合、数组），获取一个流
• 中间操作
  一个中间操作链，对数据源的数据进行处理
• 终止操作(终端操作)
  一个终止操作，执行中间操作链，并产生结果
  

---

创建 Stream

通过Collection接口创建流

Java8 中的 Collection 接口被扩展，提供了两个获取流的方法：
- default Stream stream() : 返回一个顺序流
- default Stream parallelStream() : 返回一个并行流

由数组创建流

Java8 中的 Arrays 的静态方法 stream() 可以获取数组流：
- static Stream stream(T[] array): 返回一个流
- 重载形式，能够处理对应基本类型的数组：
①public static IntStream stream(int[] array)
②public static LongStream stream(long[] array)
③public static DoubleStream stream(double[] array)

由值创建流

可以使用静态方法 Stream.of(), 通过显示值创建一个流。它可以接收任意数量的参数。
- public static Stream of(T… values) : 返回一个流

由函数创建流：创建无限流

可以使用静态方法 Stream.iterate() 和Stream.generate(), 创建无限流
- 迭代
public static Stream iterate(final T seed, finalUnaryOperator f)
- 生成
public static Stream generate(Supplier s) :

---

#

测试代码
TestCreateStream.java

package java8.stream;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.stream.IntStream;
import java.util.stream.Stream;

import org.junit.Test;

/** 
* @author 微信公众号：JavaWeb架构师
* @version 创建时间：2017年12月27日 上午10:20:05 
*/
public class TestCreateStream {
    /**
     * Stream API:
     *  1.Stream操作的特点
     *      1.1.Stream 自己不会存储元素。
     *      1.2.Stream 不会改变源对象。相反，他们会返回一个持有结果的新Stream。
     *      1.3.Stream 操作是延迟执行的。这意味着他们会等到需要结果的时候才执行。
     *  2.Stream操作的步骤
     *      2.1.创建 Stream
     *          一个数据源（如：集合、数组），获取一个流
     *      2.2.中间操作
     *          一个中间操作链，对数据源的数据进行处理
     *      2.3.终止操作(终端操作)
     *          一个终止操作，执行中间操作链，并产生结果
     *  3.创建Stream的四种方式
     *      3.1.通过Collection接口创建
     *         - default Stream<E> stream() : 返回一个顺序流
     *          - default Stream<E> parallelStream() : 返回一个并行流
     *      3.2.由数组创建流(Java8 中的 Arrays 的静态方法 stream() 可以获取数组流：)
     *          - static Stream stream(T[] array): 返回一个流   
     *          - 重载形式，能够处理对应基本类型的数组：
     *              public static IntStream stream(int[] array)
     *              public static LongStream stream(long[] array)
     *              public static DoubleStream stream(double[] array)
     *      3.3.由值创建流(可以使用静态方法 Stream.of(), 通过显示值创建一个流。它可以接收任意数量的参数。)
     *          - public static Stream of(T... values) : 返回一个流
     *      3.4.由函数创建流：创建无限流（可以使用静态方法 Stream.iterate() 和Stream.generate(), 创建无限流）
     *          - 迭代
     *              public static<T> Stream<T> iterate(final T seed, finalUnaryOperator<T> f)
     *          - 生成
     *              public static<T> Stream<T> generate(Supplier<T> s)
     */     

    /**
     * 3.1.通过Collection接口创建(下面有List和Set)
     *     default Stream<E> stream() : 返回一个顺序流
     *      default Stream<E> parallelStream() : 返回一个并行流
     */
    @Test
    public void testCtreateStream1() {
        List<String> listString = new ArrayList<>();

        /**
         * default Stream<E> stream():
         * 返回一个顺序Stream与此集合作为其来源。 
         * 当此方法应该重写spliterator()方法不能返回spliterator是IMMUTABLE ，CONCURRENT ，
         *  或后期绑定 。（详见spliterator() ） 
         * 
         * 实现要求： 
         *  默认的实现创建顺序 Stream从收集的 Spliterator 。 
         * 结果 
         *  连续 Stream在这个集合中的元素 
         */
        // 获取顺序流:stream()方法
        Stream<String> streamString1 = listString.stream();

        /**
         * default Stream<E> parallelStream():
         * 返回可能并行的Stream与此集合作为其来源。该方法允许返回顺序流。 
         * 当此方法应该重写spliterator()方法不能返回spliterator是IMMUTABLE ， CONCURRENT ，
         * 或后期绑定 。 （详见spliterator() ） 
         * 
         * 实现要求： 
         *  默认的实现创建了一个平行 Stream从收集的 Spliterator 。 
         * 结果 
         *  一个可能平行 Stream移到该集合中的元素 
         */
        // 获取并行流
        Stream<String> streamString2 = listString.parallelStream();
    }

    /**
     * 3.2.由数组创建流(Java8 中的 Arrays 的静态方法 stream() 可以获取数组流：)
     *      - static Stream stream(T[] array): 返回一个流   
     *      - 重载形式，能够处理对应基本类型的数组：
     *          public static IntStream stream(int[] array)
     *          public static LongStream stream(long[] array)
     *          public static DoubleStream stream(double[] array)
     *          ……
     */
    @Test
    public void testCreateStream2() {
        String[] strArray = new String[10];

        // 1.static Stream stream(T[] array): 返回一个流 —— 引用类型
        Stream<String> streamString = Arrays.stream(strArray);

        // 2.重载了参数，可以处理基本数据类型的数组，返回XxxStream
        IntStream intStream = Arrays.stream(new int[10]);
    }

    /**
     * 3.3.由值创建流(可以使用静态方法 Stream.of(), 通过显示值创建一个流。它可以接收任意数量的参数。)
     *      - public static Stream of(T... values) : 返回一个流
     */
    @Test
    public void testCreateStream3() {
        List<String> listStr = new ArrayList<>();
        /**
         * @SafeVarargs
         * static <T> Stream<T> of(T... values):
         * 返回其元素是指定值的顺序排序流。 
         * 
         * 参数类型 
         *  T - 流元素的类型 
         * 
         * 参数 
         *  values - 新流的元素 
         * 
         * 结果
         *  新的流 
         */
        // 创建流 
        Stream<String> streamStr = Stream.of(listStr.toArray(new String[listStr.size()]));
    }

    /**
     *  3.4.由函数创建流：创建无限流（可以使用静态方法 Stream.iterate() 和Stream.generate(), 创建无限流）
     *      - 迭代
     *          public static<T> Stream<T> iterate(final T seed, finalUnaryOperator<T> f)
     *      - 生成
     *          public static<T> Stream<T> generate(Supplier<T> s)
     */
    @Test
    public void testCreateStream4() {
        /**
         * static <T> Stream<T> iterate(T seed,
         *                  UnaryOperator<T> f):
         * 返回有序无限连续Stream由函数的迭代应用产生f至初始元素seed ，
         * 产生Stream包括seed ， f(seed) ， f(f(seed)) ，等 
         * 第一元件（位置0在） Stream将是提供seed 。 对于n > 0 ，位置n的元素
         * 将是将函数f应用于位置n - 1的元素的n - 1 。 
         * 
         * 参数类型 
         *  T - 流元素的类型 
         * 
         * 参数 
         *  seed - 初始元素 
         *  f - 要应用于前一个元素以生成新元素的函数 
         * 
         * 结果 
         *  一个新的顺序 Stream 
         */
        // 迭代
        Stream<Integer> iterateStream = Stream.iterate(0, (x) -> x+2);
        // 效果是产生从0开始，每次加2的流，不停止

        /**
         * static <T> Stream<T> generate(Supplier<T> s)：
         *  返回无限顺序无序流，其中每个元素由提供的Supplier 。 
         *  这适合于产生恒定流，随机元素流等 
         * 
         * 参数类型 
         *  T - 流元素的类型 
         * 
         * 参数 
         *  s -所述 Supplier生成的元素的 
         * 
         * 结果 
         *  一个新的无限顺序无序 Stream 
         */
        // 生成
        Stream<Double> streamDouble = Stream.generate(() -> Math.random());
        // 效果是无限产生随机数
    }
}

---

其它

• 源码下载

关注下方公众号，回复：Java8.code

• 欢迎加入交流群：451826376

• 更多信息：www.itcourse.top