《Java核心技术卷II》流的创建

流的创建

Collection接口中stream方法可以将任何集合转换为一个流。

用静态Stream.of转化成数组。

Stream words = Stream.of(contents.split("\\PL+"));

of方法具有可变长参数，可以构建具有任意数量的流。

使用Array.stream(array,from,to)可以用数组一部分创建一个流。

String.empty方法创建不包含任何元素的流。

等等，详细看代码注释。

创建流的各种方式

package streams;

import java.io.IOException;
import java.math.BigInteger;
import java.nio.file.FileSystems;
import java.nio.file.Files;
import java.nio.file.Path;
import java.util.Iterator;
import java.util.List;
import java.util.Spliterator;
import java.util.Spliterators;
import java.util.regex.Pattern;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;

public class CreatingStreams {

    public static <T> void show(String title, Stream<T> stream) {
        final int SIZE = 10;
        List<T> firstElements = stream.limit(SIZE + 1).toList();
        System.out.print(title + ": ");
        for (int i = 0; i < firstElements.size(); i++) {
            if (i > 0)
                System.out.print(", ");
            if (i < SIZE)
                System.out.print(firstElements.get(i));
            else
                System.out.print("...");
        }
        System.out.println();
    }

    public static void main(String[] args) throws IOException {
        Path path = Path.of("./resources/alice.txt");
        var contents = Files.readString(path);
//        当使用\\PL+来分割字符串时，实际上是按照非字母字符序列来进行分割。
//        例如，对于字符串"hello,world!123"，
//        使用\\PL+作为分割模式，会将字符串分割成["hello", "world", "123"]。
        //可变参数，本质上是一个数组
        Stream<String> words = Stream.of(contents.split("\\PL+"));
        show("words", words);
        //产生一个元素为给定值的流
        Stream<String> song = Stream.of("gently","down","the","stream");
        show("song", song);
        //不包含任何元素的流
        Stream<String> silence = Stream.empty();
        show("silence", silence);
        //产生一个无限流，反复调用Supplier<T>产生
        Stream<String> echos = Stream.generate(()->"Echo");
        show("echos", echos);
        //同上，生成随机数组之类的很好用
        Stream<Double> randoms = Stream.generate(Math::random);
        show("random", randoms);
        //产生无限流，通过动作，中间可以增加参数表示是否符合条件
        Stream<BigInteger> integers = Stream.iterate(
                BigInteger.ONE, t -> t.add(BigInteger.ONE));
        show("integers", integers);
        //String类由所有行构成的流
        Stream<String> greetings = "你好\n有趣的\n阿立".lines();
        show("greetings", greetings);
        //通过匹配模式返回流
        Stream<String> wordsAnotherWay = Pattern.compile("\\PL+").splitAsStream(contents);
        show("wordsAnotherWay", wordsAnotherWay);
        //指定文件中的行产生的流
        try(Stream<String> lines = Files.lines(path)){
            show("lines", lines);
        }
        //由给定分割迭代器产生的值组成的流
        Iterable<Path> iterable = FileSystems.getDefault().getRootDirectories();
        //由可分割的迭代器产生的流。
        Stream<Path> rootDirectories = StreamSupport.stream(iterable.spliterator(), false);
        show("rootDirectories", rootDirectories);
        //由可分割的迭代器产生的流。
        Iterator<Path> iterator = Path.of("D:\\主流技术\\书").iterator();
        Stream<Path> pathComponents = StreamSupport.stream(
                Spliterators.spliteratorUnknownSize(iterator, Spliterator.ORDERED), false);
        show("pathComponents", pathComponents);
    }

}