Why doesn’t java.util.Collection implement the new Stream interface?

by

Yes, there are excellent reasons for these decisions 🙂

The key is the difference between eager and lazy operations. The examples you give under the first question show eager operations where mapping or filtering a list produces a new list. There’s nothing wrong with this, but it is often not what you want, because you’re often doing way more work than you need; an eager operation must operate on every element, and produce a new collection. If you’re composing multiple operations (filter-map-reduce), you’re doing a lot of extra work. On the other hand, lazy operations compose beautifully; if you do:

Optional<Person> tallestGuy = people.stream()
                                    .filter(p -> p.getGender() == MALE)
                                    .max(comparing(Person::getHeight));

the filter and reduce (max) operations are fused together into a single pass. This is very efficient.

So, why not expose the Stream methods right on List? Well, we tried it like that. Among numerous other reasons, we found that mixing lazy methods like filter() and eager methods like removeAll() was confusing to users. By grouping the lazy methods into a separate abstraction, it becomes much clearer; the methods on List are those that mutate the list; the methods on Stream are those that deal in composible, lazy operations on data sequences regardless of where that data lives.

So, the way you suggest it is great if you want to do really simple things, but starts to fall apart when you try to build on it. Is the extra stream() method annoying? Sure. But keeping the abstractions for data structures (which are largely about organizing data in memory) and streams (which are largely about composing aggregate behavior) separate scales better to more sophisticated operations.

To your second question, you can do this relatively easily: implement the stream methods like this:

public<U> Stream<U> map(Function<T,U> mapper) { return convertToStream().map(mapper); }

But that’s just swimming against the tide; better to just implement an efficient stream() method.

More Related Contents:

  1. Does Java SE 8 have Pairs or Tuples?
  2. Convert String array to Map using Java 8 Lambda expressions
  3. Java 8 List into Map
  4. Why filter() after flatMap() is “not completely” lazy in Java streams?
  5. How to force max to return ALL maximum values in a Java Stream?
  6. Java 8 lambdas, Function.identity() or t->t
  7. Copy a stream to avoid “stream has already been operated upon or closed”
  8. Java 8 Nested (Multi level) group by
  9. Using Java 8’s Optional with Stream::flatMap
  10. Java 8 Streams: multiple filters vs. complex condition
  11. Partition a Java 8 Stream
  12. Group by and sum objects like in SQL with Java lambdas?
  13. Retrieving a List from a java.util.stream.Stream in Java 8
  14. Filter Java Stream to 1 and only 1 element
  15. Java 8, Streams to find the duplicate elements
  16. Find maximum, minimum, sum and average of a list in Java 8
  17. Java lambda returning a lambda
  18. How to use a Java8 lambda to sort a stream in reverse order?
  19. Java 8 Supplier with arguments in the constructor
  20. Java 8 Collectors.toMap SortedMap
  21. Why does Stream.allMatch() return true for an empty stream?
  22. How can I throw CHECKED exceptions from inside Java 8 lambdas/streams?
  23. How to apply multiple predicates to a java.util.Stream?
  24. Finding enum value with Java 8 Stream API
  25. Parallel stream from a HashSet doesn’t run in parallel
  26. Picking elements of a list until condition is met with Java 8 Lambdas
  27. Non-interference exact meaning in Java 8 streams
  28. Purpose of third argument to ‘reduce’ function in Java 8 functional programming
  29. Group sequences of values
  30. Java 8 stream map to list of keys sorted by values

Leave a Comment