Using a stream to iterate n times instead of using a for loop to create n items

Question

Say I want to create n items. Pre Java 8, I would write:

List<MyClass> list = new ArrayList<>();
for (int i = 0; i < n; i++) {
    list.add(new MyClass());
}

Is there an elegant way to use a stream to create n items?
I thought of this:

List<MyClass> list = Stream.iterate(0, i -> i).limit(10)
    .map(o -> new MyClass()).collect(Collectors.toList());

Is there a standard/better way of coding this?

Note that the actual usage is a bit more complex and using a stream would be more flexible because I can immediately pump the items through other functions in one line without even creating a reference to the list, for example grouping them:

Stream.iterate(0, i -> i).limit(10).map(o -> new MyClass())
    .collect(Collectors.groupingBy(...));

You think the stream will be more expressive/efficient/useful? For curiosity? — Sotirios Delimanolis, Jan 22 '15 at 04:40

score 96 · Accepted Answer · edited Aug 25 '16 at 06:21

96

You could use Stream#generate with limit:

Stream.generate(MyClass::new).limit(10);

edited Aug 25 '16 at 06:21

Andrew Tobilko

48,120
14
91
142

answered Jan 22 '15 at 05:32

Alex - GlassEditor.com

14,957
5
49
49

Why not `Stream.iterate` ? – Asif Mushtaq Oct 18 '17 at 16:42
2

@AsifMushtaq, because the state of each item is _not_ dependent upon the previous one. – Chris Goldman Apr 22 '19 at 23:55

Stuart Marks · Answer 2 · 2015-01-22T18:39:47.790

If you know n in advance, I think it's more idiomatic to use one of the stream sources that creates a stream that is known to have exactly n elements. Despite the appearances, using limit(10) doesn't necessarily result in a SIZED stream with exactly 10 elements -- it might have fewer. Having a SIZED stream improves splitting in the case of parallel execution.

As Sotirios Delimanolis noted in a comment, you could do something like this:

List<MyClass> list = IntStream.range(0, n)
    .mapToObj(i -> new MyClass())
    .collect(toList());

An alternative is this, though it's not clear to me it's any better:

List<MyClass> list2 = Collections.nCopies(10, null).stream()
    .map(o -> new MyClass())
    .collect(toList());

You could also do this:

List<MyClass> list = Arrays.asList(new MyClass[10]);
list.replaceAll(o -> new MyClass());

But this results in a fixed-size, though mutable, list.

Using a stream to iterate n times instead of using a for loop to create n items

2 Answers2

Linked