Java基础 -＞ Stream的实例化(支持顺序和并行聚合操作的一系列元素。)

package Test10月;

import org.junit.Test;

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

/**
 * 功能描述:stream支持顺序和并行聚合操作的一系列元素。
 * 创建stream
 * @version 1.0
 * @className Test1006
 * @author: 罗德
 * @create: 2020-10-06 12:22
 */
public class Test1006 {
    /**
     * 功能描述:
     * 方式一:用集合(collection)创建stream
     * 方法参数描述:无
     */
    @Test
    public void tset() {
        List<Object> list = new ArrayList<>();
        //将此流作为其源返回
        Stream<Object> stream = list.stream();
        //返回一个可能与此集合作为其源的并行流。允许此方法返回序列流。
        Stream<Object> parallelStream = list.parallelStream();
    }

    /**
     * 功能描述:
     * 方式二:用数组创建streaam
     * Arrays.stream(@NotNull object[] array)
     * 方法参数描述:无
     */
    @Test
    public void test1() {
        int[] ints = {1, 2};
        /** 
         * public static java.util.stream.IntStream stream(@NotNull int[] array)
         * 返回以指定数组作为其源的连续IntStream。
         */
        IntStream stream = Arrays.stream(ints);
    }

    /**
     * 功能描述:
     * 方式三:用stream自带的内部方法of()创建stream
     * 方法参数描述:无
     */
    @Test
    public void test2() {
        /**
         * public static <T> Stream<T> of(@NotNull T... values)
         * 返回元素为指定值的顺序有序流。
         */
        Stream<Integer> stream = Stream.of(1, 23, 3);//是integer型的
    }

    /**
     * 功能描述:
     * 方式四:创建无线流,内部方法
     * 方法参数描述:无
     */
    @Test
    public void test3() {
        /**
         * public static <T> Stream<T> iterate
         * (T seed, @NotNull java.util.function.UnaryOperator<T> f)
         * 返回由函数f迭代应用于初始元素seed生成的无限顺序有序流，
         * 生成由seed、f（seed）、f（f（seed））等组成的流。
         */
        Stream<Integer> stream = Stream.iterate(0, f -> f + 1);
        /**
         * public abstract Stream<T> limit(long maxSize)
         * 返回由此流的元素组成的流，截断后的长度不超过maxSize。
         */
        Stream<Integer> limit = stream.limit(10);
        /**
         * public abstract void forEach(java.util.function.Consumer<? super T> action)
         * 对此流的每个元素执行操作。 这是终端操作。
         */
        limit.forEach(System.out::print);//0123456789
        System.out.println('\n' + "*******************");
        /**
         * public static <T> Stream<T> generate
         * (@NotNull java.util.function.Supplier<? extends T> s)
         * 返回一个无限连续的无序流，其中每个元素都由提供的供应商生成。这适用于生成恒定流、随机元素流等。
         */
        Stream.generate(Math::random).limit(3).forEach(System.out::println);
        /**
         * 0.33589135733731856
         * 0.05392020729752112
         * 0.30168901172512097
         */
    }
}