I am trying to create a list of objects with n elements. I am trying to do this in the most java 8 way as possible. Something similar to the question asked for c# here : Creating N objects and adding them to a list
Something like this:
List <Objects> getList(int numOfElements)
{
}
If I got your question right:
List <Object> getList(int numOfElements){
return IntStream.range(0, numOfElements)
.mapToObj(Object::new) // or x -> new Object(x).. or any other constructor
.collect(Collectors.toList());
}
If you want the same object n times:
Collections.nCopies(n, T)
Collections.nCopies(n, T) will return an immutable List<T> If you need to get an editable List<T> you should create an empty List and than call addAll passing the result of nCopies List<T> temp = new ArrayList<>(); temp.addAll(Collections.nCopies(n, T)); return temp;
return new ArrayList<>(Collections.nCopies(n, T));You could use Stream.generate(Supplier<T>) in combination with a reference to a constructor and then use Stream.limit(long) to specify how many you should construct:
Stream.generate(Objects::new).limit(numOfElements).collect(Collectors.toList());
At least to me, this is more readable and illustrates intent much more clearly than using an IntStream for iteration does as e.g. Alberto Trindade Tavares suggested.
If you want something which performs better in terms of complexity and memory usage, pass the result size to Stream.collect(Collector<? super T,A,R>):
Stream.generate(Objects::new).limit(numOfElements).collect(Collectors.toCollection(() -> new ArrayList<>(numOfElements)));
IntStream approach - because this is still an infinite stream (limit will not introduce the SIZED property); otherwise +1 from me.
Arrays.asList(IntStream.range(0, numOfElements) .mapToObj(Objects::new) .toArray(Objects[]::new));ArraySpliterator would be better than RangeIntSpliterator?toArray with a (sub)sized stream will allocate the final array immediately and let each thread write into the right part of that array, in contrast to collect(Collectors.toList()) which collects into local lists and needs additional merging steps. Also, the lists used by toList() may need (multiple) capacity increase operations. See also this comment
Stream.generate(() -> new SomeClassName(someValue_01, ... , someValue_N)) .limit(size) .collect(Collectors.toList()); Or even we can pass through and custom supplier to make the generationAn equivalent implementation of the C# code you mentioned in Java 8, with streams, is the following (EDIT to use mapToObj, suggested by @Eugene):
List <Objects> getList(int numOfElements)
{
return IntStream.range(0, numOfElements)
.mapToObj(x -> new Objects())
.collect(Collectors.toList());
}
x, so it looks like it should be .map(x -> new Objects(x)) or better .map(Objects::new)
Why not keep it simple?? If you want to use LINQ or a Lambda it definetly is possible but the question is if it is more readable or maintainable.
List <Objects> getList(int numOfElements)
{
List<Objects> objectList = new LinkedList<>();
for(int i = 0; i <= numOfElements; i++)
{
objectList.add(new Object());
}
return objectList;
}
If you insist this can be the lambda:
return IntStream.range(0, numOfElements)
.mapToObj(x -> new Objects())
.collect(Collectors.toList());
Creds to @Alberto Trindade since he posted it faster than me.
If you don't mind a third-party dependency, the following will work with Eclipse Collections:
List<Object> objects = Lists.mutable.withNValues(10, Object::new);
Verify.assertSize(10, objects);
Note: I am a committer for Eclipse Collections.
