Java核心技术：Java SE 8的流库——流的创建

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

public interface Collection<E> extends Iterable<E> {
	default Stream<E> stream() {
        return StreamSupport.stream(spliterator(), false);
    }

	// java.lang.Iterable#spliterator
	@Override
    default Spliterator<E> spliterator() {
        return Spliterators.spliterator(this, 0);
    }
}

public final class StreamSupport {
	public static <T> Stream<T> stream(Spliterator<T> spliterator, boolean parallel) {
        Objects.requireNonNull(spliterator);
        return new ReferencePipeline.Head<>(spliterator,
                                            StreamOpFlag.fromCharacteristics(spliterator),
                                            parallel);
    }
}

如果有一个数组，那么可以使用静态的Stream.of方法。

Stream<String> words = Stream.of(contents.split("\\PL+"));
	// split returns a String[] array

of方法具有可变长参数因此我们可以构造具有任意数量引元的流：

Stream<String> song = Stream.of("gently", "down", "the", "stream");

public interface Stream<T> extends BaseStream<T, Stream<T>> {
	public static<T> Stream<T> of(T t) {
        return StreamSupport.stream(new Streams.StreamBuilderImpl<>(t), false);
    }
	public static<T> Stream<T> of(T... values) {
        return Arrays.stream(values);
    }
}

使用Array.stream(array, from, to)可以从数组中位于from(包括)和to(不包括)的元素中创建一个流。

public class Arrays {
	public static <T> Stream<T> stream(T[] array) {
        return stream(array, 0, array.length);
    }
    public static <T> Stream<T> stream(T[] array, int startInclusive, int endExclusive) {
        return StreamSupport.stream(spliterator(array, startInclusive, endExclusive), false);
    }
}

为了创建不包含任何元素的流，可以使用静态的stram.empty方法：

Stream<String> silence = Stream.empty();
	// Generic type <String> is inferred; same as Stream.<String>empty();

generate方法会接受一个不包含任何引元的函数。可以像厦门这样获得一个常量值的流：

Stream<String> echos = Stream.generate(() -> "Echo");

或像下面一样获取一个随机数的流：

Stream<Double> randoms = Stream.generate(Math::random);

为了生成无限序列，可以使用iterate方法。它接受一个"种子"值，以及一个函数，并且会反复地将该函数应用到之前的结果上。

Stream<BigInteger> integers = Stream.iterate(BigInteger.ZERO, n -> n.add(BigInteger.ONE));

Pattern类有一个splitAsStream方法，它会按照某个正则表达式来分割一个CharSequence对象。

Stream<String> words = Pattern.compile("\\PL+").splitAsStream(contents);

静态的Files.lines方法会返回一个包含了文件中所有行的Stream：

try(Stream<String> lines = Files.lines(path))
{
	Process lines
}