java-stream

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

This question already has an answer here : Modify file using Files.lines (1 answer) Suppose I have a java.util.stream.Stream of objects with some nice toString method: What's the shortest/most elegant solution to write this stream to a file , one line per stream element? For reading, there is the nice Files.lines method, so I thought there must be a symmetric method for writing to file, but could not find one. Files.write only takes an iterable. Tagir Valeev Probably the shortest way is to use Files.write along with the trick which converts the Stream to the Iterable : Files.write(Paths.get

Given a list of elements, I want to get the element with a given property and remove it from the list. The best solution I found is: ProducerDTO p = producersProcedureActive .stream() .filter(producer -> producer.getPod().equals(pod)) .findFirst() .get(); producersProcedureActive.remove(p); Is it possible to combine get and remove in a lambda expression? uma shankar To Remove element from the list objectA.removeIf(x -> conditions); eg: objectA.removeIf(x -> blockedWorkerIds.contains(x)); List<String> str1 = new ArrayList<String>(); str1.add("A"); str1.add("B"); str1.add("C"); str1.add("D");

I'm starting with the Stream API in Java 8. Here is my Person object I use: public class Person { private String firstName; private String lastName; private int age; private double height; private double weight; public Person(String firstName, String lastName, int age, double height, double weight) { this.firstName = firstName; this.lastName = lastName; this.age = age; this.height = height; this.weight = weight; } public String getFirstName() { return firstName; } public String getLastName() { return lastName; } public int getAge() { return age; } public double getHeight() { return height; }

List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8); List<Integer> twoEvenSquares = numbers.stream().filter(n -> { System.out.println("filtering " + n); return n % 2 == 0; }).map(n -> { System.out.println("mapping " + n); return n * n; }).limit(2).collect(Collectors.toList()); for(Integer i : twoEvenSquares) { System.out.println(i); } when executed the logic below output came filtering 1 filtering 2 mapping 2 filtering 3 filtering 4 mapping 4 4 16 if the stream follows the short circuit concept (where we use limit stream operation), then output must be like below: filtering 1

I am trying to make a List of all of the books in one Collection that are not present in another. My problem is that I need to compare based on book ID, so I can't just test to see whether a book in the first is contained in the second, I have to determine whether any book in the second collection has the same ID as a book in the first. I have the below code to compare two collections of books and filter the first collection: List<Book> parentBooks = listOfBooks1.stream().filter(book-> !listOfBooks2.contains(book)).collect(Collectors.toList()); The code doesn't work correctly because I am

In looking at some profiling results, I noticed that using streams within a tight loop (used instead of another nested loop) incurred a significant memory overhead of objects of types java.util.stream.ReferencePipeline and java.util.ArrayList$ArrayListSpliterator . I converted the offending streams to foreach loops, and the memory consumption decreased significantly. I know that streams make no promises about performing any better than ordinary loops, but I was under the impression that the difference would be negligible. In this case it seemed like it was a 40% increase. Here is the test