初始化Stream的方式

1、通过builder方式初始化stream - 无元素构建

//通过builder方式初始化stream - 无元素构建
        Stream.Builder<Integer> builder = Stream.builder();
        //add和accept都是添加一个元素
        //add添加元素后返回当前宿主,可连续添加
        builder.add(1);
        builder.add(4);
        builder.add(6).add(7).add(8);
        //accept 只添加 return void
        builder.accept(1);
        builder.accept(2);
        builder.accept(3);
        builder.build().forEach(e -> {
            System.out.println("输出当前节点: " + e);
        });

输出结果:

输出当前节点: 1
输出当前节点: 4
输出当前节点: 6
输出当前节点: 7
输出当前节点: 8
输出当前节点: 1
输出当前节点: 2
输出当前节点: 3

使用场景: 基本流操作

2、通过Stream.of()或者对象自身的.stream()方法初始化Stream - 有元素构建

        List<Integer> numberList = Lists.newArrayList(1, 2, 3, 4, 1);

        Stream.of(numberList)
                .forEach(number -> System.out.println("stream.of() -> 输出当前节点: " + number));

        numberList.stream()
                .forEach(number -> System.out.println("List.Stream() -> 输出当前节点: " + number));

输出结果:

stream.of() -> 输出当前节点: [1, 2, 3, 4, 1]

List.Stream() -> 输出当前节点: 1
List.Stream() -> 输出当前节点: 2
List.Stream() -> 输出当前节点: 3
List.Stream() -> 输出当前节点: 4
List.Stream() -> 输出当前节点: 1

使用场景: 基本流操作

3、通过两个stream合并为一个stream初始化 - 有元素构建

        List<Integer> numberList1 = Lists.newArrayList(1, 2, 3, 4, 5);
        List<Integer> numberList2 = Lists.newArrayList(6, 7, 8, 9, 10);
        
        //将两个stream合并为一个stream处理,要求两个stream任何一个都不能为null
        Stream.concat(Stream.of(numberList1), Stream.of(numberList2))
                .flatMap(Collection::stream)
                .forEach(e -> {
                    System.out.println("concat处理之后的节点,e -> " + e);
                });

输出结果:

concat处理之后的节点,e -> 1
concat处理之后的节点,e -> 2
concat处理之后的节点,e -> 3
concat处理之后的节点,e -> 4
concat处理之后的节点,e -> 5
concat处理之后的节点,e -> 6
concat处理之后的节点,e -> 7
concat处理之后的节点,e -> 8
concat处理之后的节点,e -> 9
concat处理之后的节点,e -> 10

使用场景:将两个stream合并为一个stream的处理

4、通过iterate方式初始化 - 生成无限的、有序的流

        //通过iterate方式初始化stream
        Stream.iterate(1, i -> i + 1)
                .limit(2)
                .forEach(e -> {
                    System.out.println("iterate处理之后的节点" + e);
                });

输出结果:

iterate处理之后的节点1
iterate处理之后的节点2

使用场景: 无限的有序流

5、通过generate方式创建 - 生成无限的、无序的流

/**
     * 通过generate方式创建
     * <p>
     * 生成无限的、无序的流
     * 使用场景: 恒定流、随机数等等
     */
    private static void initOfGenerate() {
        Stream.generate(new Random()::nextInt)
                .limit(5)
                .distinct()
                .forEach(e -> {
                    System.out.println("生成无序 -> 限制5个节点的流,当前节点e: - " + e);
                });
    }

输出结果:

生成无序 -> 限制5个节点的流,当前节点e: - 1428531456
生成无序 -> 限制5个节点的流,当前节点e: - -1994642612
生成无序 -> 限制5个节点的流,当前节点e: - 1501155482
生成无序 -> 限制5个节点的流,当前节点e: - 115938249
生成无序 -> 限制5个节点的流,当前节点e: - 428791818

使用场景: 恒定流、随机数等等

未完待续...