Iterators, in Java, are used in Collection Framework to retrieve elements one by one. A stream in Java is a pipeline of objects from an array or a collection data source. A sequential stream is one in which the objects are pipelined in a single stream on the same processing system.
Unlike operations directly on a concrete collection like List , operations on Iterator are lazy. A lazy operation does not immediately compute all of its results.
The Stream is a lazy lists where elements are evaluated only when they are needed. This is a scala feature. Scala supports lazy computation. It increases performance of our program. Streams have the same performance characteristics as lists.
Advertisements. An iterator is not a collection, but rather a way to access the elements of a collection one by one. The two basic operations on an iterator it are next and hasNext. A call to it.
First, they are all non-strict. That has a particular mathematical meaning related to functions, but, basically, means they are computed on-demand instead of in advance.
Stream
is a lazy list indeed. In fact, in Scala, a Stream
is a List
whose tail
is a lazy val
. Once computed, a value stays computed and is reused. Or, as you say, the values are cached.
An Iterator
can only be used once because it is a traversal pointer into a collection, and not a collection in itself. What makes it special in Scala is the fact that you can apply transformation such as map
and filter
and simply get a new Iterator
which will only apply these transformations when you ask for the next element.
Scala used to provide iterators which could be reset, but that is very hard to support in a general manner, and they didn't make version 2.8.0.
Views are meant to be viewed much like a database view. It is a series of transformation which one applies to a collection to produce a "virtual" collection. As you said, all transformations are re-applied each time you need to fetch elements from it.
Both Iterator
and views have excellent memory characteristics. Stream
is nice, but, in Scala, its main benefit is writing infinite sequences (particularly sequences recursively defined). One can avoid keeping all of the Stream
in memory, though, by making sure you don't keep a reference to its head
(for example, by using def
instead of val
to define the Stream
).
Because of the penalties incurred by views, one should usually force
it after applying the transformations, or keep it as a view if only few elements are expected to ever be fetched, compared to the total size of the view.
If you love us? You can donate to us via Paypal or buy me a coffee so we can maintain and grow! Thank you!
Donate Us With