Stream mysteriously consumed twice

The following code ends up with a java.lang.IllegalStateException: stream has already been operated upon or closed.

public static void main(String[] args) {
	Stream.concat(Stream.of("FOOBAR"),
			reverse(StreamSupport.stream(new File("FOO/BAR").toPath().spliterator(), true)
							.map(Path::toString)));
}

static <T> Stream<T> reverse(Stream<T> stream) {
	return stream.reduce(Stream.empty(),
			(Stream<T> a, T b) -> Stream.concat(Stream.of(b), a),
			(a, b) -> Stream.concat(b, a));
}

The obvious solution is to generate a non parallel stream with StreamSupport.stream(…, false), but I can’t see why can’t run in parallel.

Stream.empty() is not a constant. This method returns a new stream instance on each invocation that will get consumed like any other stream, e.g. when you pass it into Stream.concat.

Therefore, Stream.empty() is not suitable as identity value for reduce, as the identity value may get passed as input to the reduction function an arbitrary, intentionally unspecified number of times. It’s an implementation detail that is happens to be used only a single time for sequential reduction and potentially multiple times for parallel reduction.

You can use

static <T> Stream<T> reverse(Stream<T> stream) {
    return stream.map(Stream::of)
        .reduce((a, b) -> Stream.concat(b, a))
        .orElseGet(Stream::empty);
}

instead.

However, I only provide the solution as an academic exercise. As soon as the stream gets large, it leads to an excessive amount of concat calls and the note of the documentation applies:

> Use caution when constructing streams from repeated concatenation. Accessing an element of a deeply concatenated stream can result in deep call chains, or even StackOverflowError.

Generally, the resulting underlying data structure will be far more expensive than a flat list, when using the Stream API this way.

You can use something like

Stream<String> s = Stream.concat(Stream.of("FOOBAR"),
    reverse(new File("FOO/BAR").toPath()).map(Path::toString));

static Stream<Path> reverse(Path p) {
    ArrayDeque<Path> d = new ArrayDeque<>();
    p.forEach(d::addFirst);
    return d.stream();
}

or

static Stream<Path> reverse(Path p) {
    Stream.Builder b = Stream.builder();
    for(; p != null; p = p.getParent()) b.add(p.getFileName());
    return b.build();
}

With Java 9+ you can use a stream that truly has no additional storage (which does not necessarily imply that it will be more efficient):

static Stream<Path> reverse(Path p) {
    return Stream.iterate(p, Objects::nonNull, Path::getParent).map(Path::getFileName);
}