Java 8 Streams: map in stages - selenium

Question

Is it possible to carry out mappings on a stream in stages without creating intermediary collections?
I'm working with Selenium and mapping streams of WebElements. It's important to do them in batches to avoid StaleReferenceException being thrown since the page dynamically updates itself and some of the map operations take a relatively long time to complete.
Problem (simplified):
public class StreamTest {
public static void main(String[] args) {
String[] input = new String[] {"1", "2", "3", "4", "5"};
List<String> list = map(input).collect(Collectors.toList());
}
private static Stream<String> map(String[] input) {
return Arrays.stream(input).parallel()
.map(s -> {
String ret = s + "0";
System.out.println(String.format("%10s%10s", s, ret));
return ret;
})
.map(s -> {
String ret = s + "0";
System.out.println(String.format("%10s%10s", s, ret));
return ret;
})
.map(s -> {
String ret = s + "0";
System.out.println(String.format("%10s%10s", s, ret));
return ret;
});
}
}
Sample Output:
3 30
4 40
30 300
1 10
5 50
10 100
2 20
50 500
300 3000
40 400
500 5000
20 200
100 1000
400 4000
200 2000
Desired output:
1 10
2 20
3 30
4 40
5 50
10 100
20 200
30 300
40 400
50 500
100 1000
200 2000
300 3000
400 4000
500 5000
Current Solution:
private static Stream<String> map(String[] input) {
return Arrays.stream(input)
.map(s -> s + "0")
.collect(Collectors.toList()).stream()
.map(s -> s + "0")
.collect(Collectors.toList()).stream()
.map(s -> s + "0");
}
Is there a way to achieve this without creating a dummy collection between each call to map?
Note: I need to use a stream with n calls to map rather than a sequence of n for-loops.

Answer 1

This is not how streams have been designed to behave.
A sequence of map operations is applied without creating intermediate collections, only the terminal operation decides what the result will be (a collection or a single value).
But to work in batches (applying the first map operation to all input, then applying the second map operation to all first intermediate results, and so on ) you need intermediate collections.

Answer 2

This seems to work:
String[] input = new String[] {"1", "2", "3", "4", "5"};
Stream.of("", "0", "00")
.flatMap(suffix -> Stream.of(input)
.map(prefix -> prefix + suffix)
.map(s -> String.format("%10s%10s", s, s + "0")))
.forEach(System.out::println);
The bad ordering is due to the parallel() call, which can probably be avoided.

Answer 3

To be honest, no idea what you are trying to do. Here is something that would conform to your sample output:
private static Stream<String> map(String[] input) {
return Stream.of("", "0", "00")
.flatMap(x -> Arrays.stream(input)
.map(y -> y + x)
.peek(z -> System.out.println(z + " " + z + "0"))
.map(z -> z + "0"))
.skip(2 * input.length);
}
The out of order results that you see are because you are using parallel and intermediate operations have no defined order of execution, only terminal do (unless otherwise stated - forEach for example)