Stream (groovy-stream 0.9.0 API)

java.lang.Object
- groovy.stream.Stream<T>

Type Parameters:

T - the type of each element returned from the Stream.

All Implemented Interfaces:

Iterator<T>
```
public class Stream<T>
extends Object
implements Iterator<T>
```

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`Stream<Collection<T>>`	`collate(int size)` Groups a the elements of a `Stream` into groups of length `size`.
`Stream<Collection<T>>`	`collate(int size, boolean keepRemainder)` Groups a the elements of a `Stream` into groups of length `size`.
`Stream<Collection<T>>`	`collate(int size, int step)` Groups a the elements of a `Stream` into groups of length `size` using a step-size of `step`.
`Stream<Collection<T>>`	`collate(int size, int step, boolean keepRemainder)` Groups a the elements of a `Stream` into groups of length `size` using a step-size of `step`.
`Stream<T>`	`concat(Iterator<? extends T> other)` Returns a new `Stream` which will iterate the elements in the current `Stream`, followed by the elements in the `other` `Stream`.
`Stream<T>`	`filter(Closure<Boolean> predicate)` Filter the current stream, passing each element through a predicate filter.
`Stream<T>`	`filter(Predicate<T> predicate)` Filter the current stream, passing each element through a predicate filter (Java friendly version).
`Stream<T>`	`filterWithIndex(Closure<Boolean> predicate)` Filter the current stream, passing each element and it's index through a predicate filter.
`Stream<T>`	`filterWithIndex(IndexedPredicate<T> predicate)` Filter the current stream, passing each element and its index through a predicate filter (Java friendly version).
`<U> Stream<U>`	`flatMap(Closure<? extends Collection<U>> map)` Takes a `Closure` that returns a `Collection`.
`<U> Stream<U>`	`flatMap(Function<T,? extends Collection<U>> map)` Takes a `Function` that returns a `Collection`.
`<U> Stream<U>`	`flatMapWithIndex(Closure<? extends Collection<U>> map)` Takes a `Closure` that returns a `Collection`.
`<U> Stream<U>`	`flatMapWithIndex(IndexedFunction<T,? extends Collection<U>> map)` Takes an `IndexedFunction` that returns a `Collection`.
`static Stream<Boolean>`	`from(boolean[] array)` Construct a `Stream` that iterates every `Boolean` in an array.
`static Stream<String>`	`from(BufferedReader reader)` Construct a `Stream` from a `BufferedReader` that iterates the lines in it.
`static Stream<Byte>`	`from(byte[] array)` Construct a `Stream` that iterates every `byte` in an array.
`static Stream<Character>`	`from(char[] array)` Construct a `Stream` that iterates every `Character` in an array.
`static <T> Stream<T>`	`from(Closure<T> closure)` Construct a `Stream` that for every element, returns the result of calling the `Closure`.
`static Stream<Double>`	`from(double[] array)` Construct a `Stream` that iterates every `Double` in an array.
`static Stream<Float>`	`from(float[] array)` Construct a `Stream` that iterates every `Float` in an array.
`static Stream<Integer>`	`from(int[] array)` Construct a `Stream` that iterates every `Integer` in an array.
`static <T> Stream<T>`	`from(Iterable<T> iterable)` Construct a `Stream` from an `Iterable`.
`static <T> Stream<T>`	`from(Iterator<T> iterator)` Construct a `Stream` from an `Iterator`.
`static Stream<JarEntry>`	`from(JarFile file)` Construct a `Stream` from a `JarFile` that iterates the `JarEntry` objects contained within.
`static Stream<Long>`	`from(long[] array)` Construct a `Stream` that iterates every `Long` in an array.
`static <K,V> Stream<Map<K,V>>`	`from(Map<K,? extends Iterable<V>> map)` Construct a `Stream` from a `Map` of Iterables.
`static Stream<Short>`	`from(short[] array)` Construct a `Stream` that iterates every `Short` in an array.
`static <T> Stream<T>`	`from(Stream<T> stream)` Construct a `Stream` from another `Stream`.
`static <T> Stream<T>`	`from(T object)` Construct a `Stream` that for every element, returns `object`.
`static <T> Stream<T>`	`from(T[] array)` Construct a `Stream` that iterates every `Object` in an array.
`static Stream<ZipEntry>`	`from(ZipFile file)` Construct a `Stream` from a `ZipFile` that iterates the `ZipEntry` objects contained within.
`boolean`	`hasNext()`
`<U> Stream<U>`	`map(Closure<U> map)` Maps the elements of a `Stream` to a new value as they are requested.
`<U> Stream<U>`	`map(Function<T,U> map)` Maps the elements of a `Stream` to a new value as they are requested.
`<U> Stream<U>`	`mapWithIndex(Closure<U> map)` Maps the elements of a `Stream` to a new value as they are requested.
`<U> Stream<U>`	`mapWithIndex(IndexedFunction<T,U> map)` Maps the elements of a `Stream` to a new value as they are requested.
`T`	`next()`
`void`	`remove()`
`Stream<T>`	`repeat()` When this stream completes, repeat it's output endlessly.
`Stream<T>`	`repeat(int count)` This stream will repeat `count` times.
`Stream<T>`	`skip(int n)` Skip `n` elements.
`Stream<T>`	`take(int n)` Limits the `Stream` to `n` elements.
`Stream<T>`	`tap(Closure<Void> output)` Inspect every value in the `Stream` and pass it on unmodified.
`Stream<T>`	`tap(Function<T,Void> output)` Inspect every value in the `Stream` and pass it on.
`Stream<T>`	`tapEvery(int n, Closure<Void> output)` Inspect the every nth value in the `Stream` and pass it on unmodified.
`Stream<T>`	`tapEvery(int n, Function<T,Void> output)` Inspect the every nth value in the `Stream` and pass it on.
`Stream<T>`	`tapEveryWithIndex(int n, Closure<Void> output)` Inspect the every nth value in the `Stream` with its index and pass it on unmodified.
`Stream<T>`	`tapEveryWithIndex(int n, IndexedFunction<T,Void> output)` Inspect the every nth value in the `Stream` with its index and pass it on unmodified.
`Stream<T>`	`tapWithIndex(Closure<Void> output)` Inspect every value in the `Stream` with its `index` and pass it on unmodified.
`Stream<T>`	`tapWithIndex(IndexedFunction<T,Void> output)` Inspect every value in the `Stream` with its `index` and pass it on unmodified.
`Stream<T>`	`until(Closure<Boolean> predicate)` When the `Closure` predicate returns `true`, the stream is stopped.
`Stream<T>`	`until(Predicate<T> predicate)` When the `Predicate` returns `true`, the stream is stopped.
`Stream<T>`	`untilWithIndex(Closure<Boolean> predicate)` Calls the `Closure` predicate with the current element and the index in the stream.
`Stream<T>`	`untilWithIndex(IndexedPredicate<T> predicate)` Calls the `IndexedPredicate` with the current element and the index in the stream.
`<U,V> Stream<V>`	`zip(Iterable<U> other, Closure<V> map)`
`<U,V> Stream<V>`	`zip(Iterable<U> other, Function2<T,U,V> map)`
`<U,V> Stream<V>`	`zip(Iterator<U> other, Closure<V> map)` Takes another `Iterator` or `Stream` and calls the two arg `Closure` to zip the two together.
`<U,V> Stream<V>`	`zip(Iterator<U> other, Function2<T,U,V> map)` Takes another `Iterator` or `Stream` and calls the two arg `Function2` to zip the two together.
`<U,V> Stream<V>`	`zipWithIndex(Iterable<U> other, Closure<V> map)`
`<U,V> Stream<V>`	`zipWithIndex(Iterable<U> other, IndexedFunction2<T,U,V> map)`
`<U,V> Stream<V>`	`zipWithIndex(Iterator<U> other, Closure<V> map)` Takes another `Iterator` or `Stream` and calls the three arg `Closure` to zip the two together along with the current index.
`<U,V> Stream<V>`	`zipWithIndex(Iterator<U> other, IndexedFunction2<T,U,V> map)` Takes another `Iterator` or `Stream` and calls the three arg `IndexedFunction2` to zip the two together along with the current index.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface java.util.Iterator
forEachRemaining

- Method Detail
 - filter
```
public Stream<T> filter(Closure<Boolean> predicate)
```
 Filter the current stream, passing each element through a predicate filter.
```
 import groovy.stream.*

 assert Stream.from( 1..3 )
 .filter { it % 2 == 1 }
 .collect() == [ 1, 3 ]
 
```
 Parameters:
 
 predicate - A single parameter closure to pass the element through, returning true if the element is to be included.
 
 Returns:
 
 A new Stream wrapping a FilteringIterator
 - filter
```
public Stream<T> filter(Predicate<T> predicate)
```
 Filter the current stream, passing each element through a predicate filter (Java friendly version).
 
 Parameters:
 
 predicate - A Predicate instance returning true from it's call method if the element is to be included.
 
 Returns:
 
 A new Stream wrapping a FilteringIteratorForPredicate
 - filterWithIndex
```
public Stream<T> filterWithIndex(Closure<Boolean> predicate)
```
 Filter the current stream, passing each element and it's index through a predicate filter.
```
 import groovy.stream.*

 assert Stream.from( 1..3 )
 .filterWithIndex { it, index -> index % 2 == 1 }
 .collect() == [ 2 ]
 
```
 Parameters:
 
 predicate - A two parameter closure, the first parameter being the element in the Stream, the second the index (starting at 0).
 
 Returns:
 
 A new Stream wrapping a FilteringIterator
 - filterWithIndex
```
public Stream<T> filterWithIndex(IndexedPredicate<T> predicate)
```
 Filter the current stream, passing each element and its index through a predicate filter (Java friendly version).
 
 Parameters:
 
 predicate - An IndexedPredicate instance returning true from it's call method if the element is to be included.
 
 Returns:
 
 A new Stream wrapping a FilteringIteratorForIndexedPredicate
 - concat
```
public Stream<T> concat(Iterator<? extends T> other)
```
 Returns a new Stream which will iterate the elements in the current Stream, followed by the elements in the other Stream.
```
 import groovy.stream.*

 def a = Stream.from( 1..3 )
 def b = Stream.from( 'a'..'c' )

 assert a.concat( b ).collect() == [ 1, 2, 3, 'a', 'b', 'c' ]
 
```
 Parameters:
 
 other - The Stream to iterate after the current one is exhausted.
 
 Returns:
 
 A new Stream wrapping a ConcatenationIterator
 - skip
```
public Stream<T> skip(int n)
```
 Skip n elements.
```
 import groovy.stream.*

 assert Stream.from( 1..10 )
 .skip( 6 ).collect() == [ 7, 8, 9, 10 ]
 
```
 Parameters:
 
 n - the number of elements to skip
 
 Returns:
 
 A new Stream wrapping a SkipIterator
 - flatMap
```
public  Stream flatMap(Closure<? extends Collection> map)
```
 Takes a Closure that returns a Collection. Each element in this Collection is passed on in turn, before the next element is fetched from upstream, and the Closure executed again.
```
 import groovy.stream.*

 assert Stream.from( 1..3 )
 .flatMap { [ it ] * it }
 .collect() == [ 1, 2, 2, 3, 3, 3 ]
 
```
 Type Parameters:
 
 U - The type of the new Stream.
 
 Parameters:
 
 map - A single parameter closure to pass the element through, returning a new Collection of elements to iterate.
 
 Returns:
 
 A new Stream wrapping a FlatMapIterator
 - flatMap
```
public  Stream flatMap(Function<T,? extends Collection> map)
```
 Takes a Function that returns a Collection. Each element in this Collection is passed on in turn, before the next element is fetched from upstream, and the Function is executed again.
 
 Type Parameters:
 
 U - The type of the new Stream.
 
 Parameters:
 
 map - A single Function to pass the element through, returning a new Collection of elements to iterate.
 
 Returns:
 
 A new Stream wrapping a FlatMapIteratorForFunction
 - flatMapWithIndex
```
public  Stream flatMapWithIndex(Closure<? extends Collection> map)
```
 Takes a Closure that returns a Collection. Each element in this Collection is passed on in turn, before the next element is fetched from upstream, and the Closure executed again.
```
 import groovy.stream.*

 assert Stream.from( 1..3 )
 .flatMapWithIndex { it, index -> [ it ] * index }
 .collect() == [ 2, 3, 3 ]
 
```
 Type Parameters:
 
 U - The type of the new Stream.
 
 Parameters:
 
 map - A two parameter closure to pass the element and it's index through, returning a new Collection of elements to iterate.
 
 Returns:
 
 A new Stream wrapping a FlatMapIterator
 - flatMapWithIndex
```
public  Stream flatMapWithIndex(IndexedFunction<T,? extends Collection> map)
```
 Takes an IndexedFunction that returns a Collection. Each element in this Collection is passed on in turn, before the next element is fetched from upstream, and the IndexedFunction is executed again.
 
 Type Parameters:
 
 U - The type of the new Stream.
 
 Parameters:
 
 map - A single IndexedFunction to pass the element and its index through, returning a new Collection of elements to iterate.
 
 Returns:
 
 A new Stream wrapping a FlatMapIteratorForIndexedFunction
 - tap
```
public Stream<T> tap(Closure<Void> output)
```
 Inspect every value in the Stream and pass it on unmodified.
```
 import groovy.stream.*

 def list = []
 assert Stream.from( 1..3 )
 .tap { list << it }
 .collect() == [ 1, 2, 3 ]
 assert list == [ 1, 2, 3 ]
 
```
 Parameters:
 
 output - The Closure to be called for every element
 
 Returns:
 
 A new Stream wrapping a TapIterator
 - tap
```
public Stream<T> tap(Function<T,Void> output)
```
 Inspect every value in the Stream and pass it on.
 
 Parameters:
 
 output - The Function to be called for every element
 
 Returns:
 
 A new Stream wrapping a TapIteratorForFunction
 
 See Also:
 
 tap(groovy.lang.Closure)
 - tapEvery
```
public Stream<T> tapEvery(int n,
 Closure<Void> output)
```
 Inspect the every nth value in the Stream and pass it on unmodified.
```
 import groovy.stream.*

 def list = []
 assert Stream.from( 1..3 )
 .tapEvery( 2 ) { list << it }
 .collect() == [ 1, 2, 3 ]
 assert list == [ 2 ]
 
```
 Parameters:
 
 n - the elements to inspect
 
 output - The Closure to be called for every nth element
 
 Returns:
 
 A new Stream wrapping a TapIterator
 - tapEvery
```
public Stream<T> tapEvery(int n,
 Function<T,Void> output)
```
 Inspect the every nth value in the Stream and pass it on.
 
 Parameters:
 
 n - the elements to inspect
 
 output - The Function to be called for every nth element
 
 Returns:
 
 A new Stream wrapping a TapIteratorForFunction
 
 See Also:
 
 tapEvery(int, groovy.lang.Closure)
 - tapWithIndex
```
public Stream<T> tapWithIndex(Closure<Void> output)
```
 Inspect every value in the Stream with its index and pass it on unmodified.
```
 import groovy.stream.*

 def list = []
 assert Stream.from( 1..3 )
 .tapWithIndex { it, idx -> list << [ (it):idx ] }
 .collect() == [ 1, 2, 3 ]
 assert list == [ [ 1:0 ], [ 2:1 ], [ 3:2 ] ]
 
```
 Parameters:
 
 output - The closure to call for each element in the Stream.
 
 Returns:
 
 A new Stream wrapping a TapIterator
 - tapWithIndex
```
public Stream<T> tapWithIndex(IndexedFunction<T,Void> output)
```
 Inspect every value in the Stream with its index and pass it on unmodified.
 
 Parameters:
 
 output - The IndexedFunction to call for each element in the Stream.
 
 Returns:
 
 A new Stream wrapping a TapIteratorForIndexedFunction
 
 See Also:
 
 tapWithIndex(groovy.lang.Closure)
 - tapEveryWithIndex
```
public Stream<T> tapEveryWithIndex(int n,
 Closure<Void> output)
```
 Inspect the every nth value in the Stream with its index and pass it on unmodified.
```
 import groovy.stream.*

 def list = []
 assert Stream.from( 1..3 )
 .tapEveryWithIndex( 2 ) { it, index -> list << [ (it):index ] }
 .collect() == [ 1, 2, 3 ]
 assert list == [ [2:1] ]
 
```
 Parameters:
 
 n - the elements to inspect
 
 output - The Closure to be called for every nth element
 
 Returns:
 
 A new Stream wrapping a TapIterator
 - tapEveryWithIndex
```
public Stream<T> tapEveryWithIndex(int n,
 IndexedFunction<T,Void> output)
```
 Inspect the every nth value in the Stream with its index and pass it on unmodified.
 
 Parameters:
 
 n - the elements to inspect
 
 output - The IndexedFunction to be called for every nth element
 
 Returns:
 
 A new Stream wrapping a TapIteratorForIndexedFunction
 
 See Also:
 
 tapEveryWithIndex(int, groovy.lang.Closure)
 - map
```
public  Stream map(Closure map)
```
 Maps the elements of a Stream to a new value as they are requested. Each element is passed in to a one arg closure, and the result of the Closure is returned as the next element in the Stream. The element is also set as the delegate of the Closure, so you can access map entries by name.
```
 import groovy.stream.*

 assert Stream.from( x:1..3, y:'a'..'c' )
 .map { "$x:$y" }
 .collect() == [ "1:a", "1:b", "1:c",
 "2:a", "2:b", "2:c",
 "3:a", "3:b", "3:c" ]
 
```
 Type Parameters:
 
 U - The type of the new Stream.
 
 Parameters:
 
 map - The transforming Closure.
 
 Returns:
 
 A new Stream wrapping a TransformingIterator
 - map
```
public  Stream map(Function<T,U> map)
```
 Maps the elements of a Stream to a new value as they are requested. Each element is passed in to a Function, the result of which is returned as the next element in the Stream.
 
 Type Parameters:
 
 U - The type of the new Stream.
 
 Parameters:
 
 map - The transforming Function.
 
 Returns:
 
 A new Stream wrapping a TransformingIteratorForFunction
 
 See Also:
 
 map(groovy.lang.Closure)
 - mapWithIndex
```
public  Stream mapWithIndex(Closure map)
```
 Maps the elements of a Stream to a new value as they are requested. Each element plus an index is passed in to a two arg closure, and the result of the Closure is returned as the next element in the Stream. The element is also set as the delegate of the Closure, so you can access map entries by name.
```
 import groovy.stream.*

 assert Stream.from( x:1..3, y:'a'..'c' )
 .mapWithIndex { it, idx -> "${x}:${it.y}:${idx}" }
 .collect() == [ "1:a:0", "1:b:1", "1:c:2",
 "2:a:3", "2:b:4", "2:c:5",
 "3:a:6", "3:b:7", "3:c:8" ]
 
```
 Type Parameters:
 
 U - The type of the new Stream.
 
 Parameters:
 
 map - The transforming Closure.
 
 Returns:
 
 A new Stream wrapping a TransformingIterator
 - mapWithIndex
```
public  Stream mapWithIndex(IndexedFunction<T,U> map)
```
 Maps the elements of a Stream to a new value as they are requested. Each element plus an index is passed in to an IndexedFunction, and the result of this is returned as the next element in the Stream.
 
 Type Parameters:
 
 U - The type of the new Stream.
 
 Parameters:
 
 map - The transforming IndexedFunction.
 
 Returns:
 
 A new Stream wrapping a TransformingIteratorForIndexedFunction
 
 See Also:
 
 mapWithIndex(groovy.lang.Closure)
 - until
```
public Stream<T> until(Closure<Boolean> predicate)
```
 When the Closure predicate returns true, the stream is stopped.
```
 import groovy.stream.*

 assert Stream.from( 1..5 )
 .until { it > 3 }
 .collect() == [ 1, 2, 3 ]
 
```
 Parameters:
 
 predicate - The Closure that stops the Stream when it returns true.
 
 Returns:
 
 A new Stream wrapping an UntilIterator
 - until
```
public Stream<T> until(Predicate<T> predicate)
```
 When the Predicate returns true, the stream is stopped.
 
 Parameters:
 
 predicate - The Predicate that stops the Stream when it returns true.
 
 Returns:
 
 A new Stream wrapping an UntilIteratorForPredicate
 
 See Also:
 
 until(groovy.lang.Closure)
 - untilWithIndex
```
public Stream<T> untilWithIndex(Closure<Boolean> predicate)
```
 Calls the Closure predicate with the current element and the index in the stream. When the predicate returns true, the stream is stopped.
```
 import groovy.stream.*

 assert Stream.from( 1..5 )
 .untilWithIndex { it, index -> index == 2 }
 .collect() == [ 1, 2 ]
 
```
 Parameters:
 
 predicate - The Closure that stops the Stream when it returns true.
 
 Returns:
 
 A new Stream wrapping an UntilIterator
 - untilWithIndex
```
public Stream<T> untilWithIndex(IndexedPredicate<T> predicate)
```
 Calls the IndexedPredicate with the current element and the index in the stream. When the predicate returns true, the stream is stopped.
 
 Parameters:
 
 predicate - The IndexedPredicate that stops the Stream when it returns true.
 
 Returns:
 
 A new Stream wrapping an UntilIteratorForIndexedPredicate
 - collate
```
public Stream<Collection<T>> collate(int size)
```
 Groups a the elements of a Stream into groups of length size.
```
 import groovy.stream.*

 assert Stream.from( 1..9 )
 .collate( 4 )
 .collect() == [ [ 1, 2, 3, 4 ], [ 5, 6, 7, 8 ], [ 9 ] ]
 
```
 Parameters:
 
 size - the size of each collated group
 
 Returns:
 
 A new Stream wrapping an CollatingIterator
 - collate
```
public Stream<Collection<T>> collate(int size,
 boolean keepRemainder)
```
 Groups a the elements of a Stream into groups of length size.
```
 import groovy.stream.*

 assert Stream.from( 1..9 )
 .collate( 4, false )
 .collect() == [ [ 1, 2, 3, 4 ], [ 5, 6, 7, 8 ] ]
 
```
 Parameters:
 
 size - the size of each collated group
 
 keepRemainder - Should any remaining objects be returned at the end
 
 Returns:
 
 A new Stream wrapping an CollatingIterator
 - collate
```
public Stream<Collection<T>> collate(int size,
 int step)
```
 Groups a the elements of a Stream into groups of length size using a step-size of step.
```
 import groovy.stream.*

 assert Stream.from( 1..9 )
 .collate( 4, 1 )
 .collect() == [ [ 1, 2, 3, 4 ],
 [ 2, 3, 4, 5 ],
 [ 3, 4, 5, 6 ],
 [ 4, 5, 6, 7 ],
 [ 5, 6, 7, 8 ],
 [ 6, 7, 8, 9 ],
 [ 7, 8, 9 ],
 [ 8, 9 ],
 [ 9 ] ]
 
```
 Parameters:
 
 size - the size of each collated group
 
 step - How many to increment the window by each turn
 
 Returns:
 
 A new Stream wrapping an CollatingIterator
 - collate
```
public Stream<Collection<T>> collate(int size,
 int step,
 boolean keepRemainder)
```
 Groups a the elements of a Stream into groups of length size using a step-size of step.
```
 import groovy.stream.*

 assert Stream.from( 1..9 )
 .collate( 4, 1, false )
 .collect() == [ [ 1, 2, 3, 4 ],
 [ 2, 3, 4, 5 ],
 [ 3, 4, 5, 6 ],
 [ 4, 5, 6, 7 ],
 [ 5, 6, 7, 8 ],
 [ 6, 7, 8, 9 ] ]
 
```
 Parameters:
 
 size - the size of each collated group
 
 step - How many to increment the window by each turn
 
 keepRemainder - Should any remaining objects be returned at the end
 
 Returns:
 
 A new Stream wrapping an CollatingIterator
 - zip
```
public <U,V> Stream<V> zip(Iterator other,
 Closure<V> map)
```
 Takes another Iterator or Stream and calls the two arg Closure to zip the two together.
```
 import groovy.stream.*

 def numbers = Stream.from 1..3
 def letters = Stream.from 'a'..'d'
 
 assert numbers.zip( letters ) { n, l -> "$n:$l" }
 .collect() == [ "1:a", "2:b", "3:c" ]
 
```
 Type Parameters:
 
 U - The type of the secondary Iterator.
 
 V - The type of the new Iterator.
 
 Parameters:
 
 other - The other Iterator
 
 map - The 2 arg Closure to call with each next element from the Stream
 
 Returns:
 
 A new Stream wrapping a ZipIterator
 - zip
```
public <U,V> Stream<V> zip(Iterable other,
 Closure<V> map)
```
 - zip
```
public <U,V> Stream<V> zip(Iterator other,
 Function2<T,U,V> map)
```
 Takes another Iterator or Stream and calls the two arg Function2 to zip the two together.
 
 Type Parameters:
 
 U - The type of the secondary Iterator.
 
 V - The type of the new Iterator.
 
 Parameters:
 
 other - The other Iterator
 
 map - The 2 arg Function2 to call with each next element from the Stream
 
 Returns:
 
 A new Stream wrapping a ZipIteratorForFunction
 
 See Also:
 
 zip(java.util.Iterator, groovy.lang.Closure)
 - zip
```
public <U,V> Stream<V> zip(Iterable other,
 Function2<T,U,V> map)
```
 - zipWithIndex
```
public <U,V> Stream<V> zipWithIndex(Iterator other,
 Closure<V> map)
```
 Takes another Iterator or Stream and calls the three arg Closure to zip the two together along with the current index.
```
 import groovy.stream.*

 def numbers = Stream.from 1..3
 def letters = Stream.from 'a'..'d'
 
 assert numbers.zipWithIndex( letters ) { n, l, i -> "$n:$l:$i" }
 .collect() == [ "1:a:0", "2:b:1", "3:c:2" ]
 
```
 Type Parameters:
 
 U - The type of the secondary Iterator.
 
 V - The type of the new Iterator.
 
 Parameters:
 
 other - The other Iterator
 
 map - The 3 arg Closure to call with each next element from the Stream and the current stream index
 
 Returns:
 
 A new Stream wrapping a ZipIterator
 - zipWithIndex
```
public <U,V> Stream<V> zipWithIndex(Iterable other,
 Closure<V> map)
```
 - zipWithIndex
```
public <U,V> Stream<V> zipWithIndex(Iterator other,
 IndexedFunction2<T,U,V> map)
```
 Takes another Iterator or Stream and calls the three arg IndexedFunction2 to zip the two together along with the current index.
 
 Type Parameters:
 
 U - The type of the secondary Iterator.
 
 V - The type of the new Iterator.
 
 Parameters:
 
 other - The other Iterator
 
 map - The 3 arg IndexedFunction2 to call with each next element from the Stream and the current stream index
 
 Returns:
 
 A new Stream wrapping a ZipIteratorForIndexedFunction
 
 See Also:
 
 zipWithIndex(java.util.Iterator, groovy.lang.Closure)
 - zipWithIndex
```
public <U,V> Stream<V> zipWithIndex(Iterable other,
 IndexedFunction2<T,U,V> map)
```
 - repeat
```
public Stream<T> repeat()
```
 When this stream completes, repeat it's output endlessly.
```
 import groovy.stream.*

 def numbers = Stream.from 1..3

 // We will just take the first 12 elements of this infinite stream
 assert numbers.repeat().take(12).collect() == [1,2,3,1,2,3,1,2,3,1,2,3]
 
```
 Returns:
 
 A new Stream wrapping a RepeatingIterator
 - repeat
```
public Stream<T> repeat(int count)
```
 This stream will repeat count times. If count is 0, the Stream will be empty. If 1, no repetition will be performed.
```
 import groovy.stream.*

 def numbers = Stream.from(['alice', 'bob'])

 assert numbers.repeat(2).collect() == ['alice','bob','alice','bob']
 
```
 Parameters:
 
 count - The number of times to repeat the element in this Stream once it is exhausted.
 
 Returns:
 
 A new Stream wrapping a RepeatingIterator
 - take
```
public Stream<T> take(int n)
```
 Limits the Stream to n elements.
```
 import groovy.stream.*

 assert Stream.from( 1..9 )
 .take( 3 )
 .collect() == [ 1, 2, 3 ]
 
```
 Parameters:
 
 n - The number of element to limit the Stream to.
 
 Returns:
 
 A new Stream wrapping a LimitedIterator
 - from
```
public static <K,V> Stream<Map<K,V>> from(Map<K,? extends Iterable<V>> map)
```
 Construct a Stream from a Map of Iterables.
```
 import groovy.stream.*

 assert Stream.from( a:1..3, b:'a'..'c' )
 .collect() == [ [ a:1, b:'a' ],
 [ a:1, b:'b' ],
 [ a:1, b:'c' ],
 [ a:2, b:'a' ],
 [ a:2, b:'b' ],
 [ a:2, b:'c' ],
 [ a:3, b:'a' ],
 [ a:3, b:'b' ],
 [ a:3, b:'c' ] ]
 
```
 Type Parameters:
 
 K - They type of the Map keys.
 
 V - The type of the Iterable value.
 
 Parameters:
 
 map - The map of Iterables.
 
 Returns:
 
 A new Stream wrapping a MapIterator.
 - from
```
public static <T> Stream<T> from(Stream<T> stream)
```
 Construct a Stream from another Stream.
```
 import groovy.stream.*

 assert Stream.from( Stream.from( 1..3 ) )
 .collect() == [ 1, 2, 3 ]
 
```
 Type Parameters:
 
 T - The type of the Stream.
 
 Parameters:
 
 stream - The other Stream.
 
 Returns:
 
 A new Stream wrapping the iterator of the other Stream.
 - from
```
public static <T> Stream<T> from(Iterable<T> iterable)
```
 Construct a Stream from an Iterable.
```
 import groovy.stream.*

 assert Stream.from( [ 1, 2, 3 ] )
 .collect() == [ 1, 2, 3 ]
 
```
 Type Parameters:
 
 T - The type of the Iterable.
 
 Parameters:
 
 iterable - The iterable to iterate.
 
 Returns:
 
 A new Stream wrapping the iterable.iterator().
 - from
```
public static <T> Stream<T> from(Iterator<T> iterator)
```
 Construct a Stream from an Iterator.
```
 import groovy.stream.*

 assert Stream.from( [ 1, 2, 3 ].iterator() )
 .collect() == [ 1, 2, 3 ]
 
```
 Type Parameters:
 
 T - The type of the Iterator.
 
 Parameters:
 
 iterator - The iterator to wrap.
 
 Returns:
 
 A new Stream wrapping the iterator.
 - from
```
public static Stream<String> from(BufferedReader reader)
```
 Construct a Stream from a BufferedReader that iterates the lines in it.
 
 Parameters:
 
 reader - The Reader to iterate lines from
 
 Returns:
 
 A new Stream wrapping a BufferedReaderIterator.
 - from
```
public static Stream<ZipEntry> from(ZipFile file)
```
 Construct a Stream from a ZipFile that iterates the ZipEntry objects contained within.
 
 Parameters:
 
 file - the ZipFile to iterate ZipEntrys from.
 
 Returns:
 
 A new Stream wrapping an EnumerationIterator.
 - from
```
public static Stream<JarEntry> from(JarFile file)
```
 Construct a Stream from a JarFile that iterates the JarEntry objects contained within.
 
 Parameters:
 
 file - the JarFile to iterate JarEntrys from.
 
 Returns:
 
 A new Stream wrapping an EnumerationIterator.
 - from
```
public static <T> Stream<T> from(Closure<T> closure)
```
 Construct a Stream that for every element, returns the result of calling the Closure.
 
 Type Parameters:
 
 T - The type of the return value from the Closure.
 
 Parameters:
 
 closure - The closure to call each time an element is requested.
 
 Returns:
 
 A new Stream wrapping an RepeatingClosureIterator.
 - from
```
public static <T> Stream<T> from(T object)
```
 Construct a Stream that for every element, returns object.
```
 import groovy.stream.*

 assert Stream.from( 1 ).take( 3 ).collect() == [ 1, 1, 1 ]
 
```
 Type Parameters:
 
 T - The type of the Object.
 
 Parameters:
 
 object - The object to return each time an element is requested.
 
 Returns:
 
 A new Stream wrapping an RepeatingObjectIterator.
 - from
```
public static <T> Stream<T> from(T[] array)
```
 Construct a Stream that iterates every Object in an array. First converts the array to an ArrayList, then wraps the ArrayList.iterator().
```
 import groovy.stream.*

 String[] elems = [ 'one', 'two', 'three' ]

 assert Stream.from( elems ).collect() == [ 'one', 'two', 'three' ]
 
```
 Type Parameters:
 
 T - The type of the array.
 
 Parameters:
 
 array - An array of Object to iterate
 
 Returns:
 
 A new Stream wrapping the iterator for the array as a List.
 - from
```
public static Stream<Byte> from(byte[] array)
```
 Construct a Stream that iterates every byte in an array. First converts the array to an ArrayList, then wraps the ArrayList.iterator().
```
 import groovy.stream.*

 byte[] elems = [ 127, 128, 129 ]

 assert Stream.from( elems ).collect() == [ 127, -128, -127 ]
 
```
 Parameters:
 
 array - An array of byte to iterate
 
 Returns:
 
 A new Stream wrapping the iterator for the array as a List.
 - from
```
public static Stream<Character> from(char[] array)
```
 Construct a Stream that iterates every Character in an array. First converts the array to an ArrayList, then wraps the ArrayList.iterator().
```
 import groovy.stream.*

 char[] elems = 'Hello'.toList()

 assert Stream.from( elems ).collect() == [ 'H', 'e', 'l', 'l', 'o' ]
 
```
 Parameters:
 
 array - An array of char to iterate
 
 Returns:
 
 A new Stream wrapping the iterator for the array as a List.
 - from
```
public static Stream<Short> from(short[] array)
```
 Construct a Stream that iterates every Short in an array. First converts the array to an ArrayList, then wraps the ArrayList.iterator().
```
 import groovy.stream.*

 short[] elems = [ 10, 65535, 65536, 65537, 99 ]

 assert Stream.from( elems ).collect() == [ 10, -1, 0, 1, 99 ]
 
```
 Parameters:
 
 array - An array of short to iterate
 
 Returns:
 
 A new Stream wrapping the iterator for the array as a List.
 - from
```
public static Stream<Integer> from(int[] array)
```
 Construct a Stream that iterates every Integer in an array. First converts the array to an ArrayList, then wraps the ArrayList.iterator().
```
 import groovy.stream.*

 int[] elems = [ 10, 65535, 65536, 65537, 99 ]

 assert Stream.from( elems ).collect() == [ 10, 65535, 65536, 65537, 99 ]
 
```
 Parameters:
 
 array - An array of int to iterate
 
 Returns:
 
 A new Stream wrapping the iterator for the array as a List.
 - from
```
public static Stream<Long> from(long[] array)
```
 Construct a Stream that iterates every Long in an array. First converts the array to an ArrayList, then wraps the ArrayList.iterator().
```
 import groovy.stream.*

 long[] elems = [ 10, 65535, 65536, 65537, 99 ]

 assert Stream.from( elems ).collect() == [ 10, 65535, 65536, 65537, 99 ]
 
```
 Parameters:
 
 array - An array of long to iterate
 
 Returns:
 
 A new Stream wrapping the iterator for the array as a List.
 - from
```
public static Stream<Float> from(float[] array)
```
 Construct a Stream that iterates every Float in an array. First converts the array to an ArrayList, then wraps the ArrayList.iterator().
```
 import groovy.stream.*

 float[] elems = [ 0.1, 0.2, 0.3 ]

 assert Stream.from( elems ).collect() == [ 0.1f, 0.2f, 0.3f ]
 
```
 Parameters:
 
 array - An array of float to iterate
 
 Returns:
 
 A new Stream wrapping the iterator for the array as a List.
 - from
```
public static Stream<Double> from(double[] array)
```
 Construct a Stream that iterates every Double in an array. First converts the array to an ArrayList, then wraps the ArrayList.iterator().
```
 import groovy.stream.*

 double[] elems = [ 0.1, 0.2, 0.3 ]

 assert Stream.from( elems ).collect() == [ 0.1, 0.2, 0.3 ]
 
```
 Parameters:
 
 array - An array of double to iterate
 
 Returns:
 
 A new Stream wrapping the iterator for the array as a List.
 - from
```
public static Stream<Boolean> from(boolean[] array)
```
 Construct a Stream that iterates every Boolean in an array. First converts the array to an ArrayList, then wraps the ArrayList.iterator().
```
 import groovy.stream.*

 boolean[] elems = [ true, false ]

 assert Stream.from( elems ).collect() == [ true, false ]
 
```
 Parameters:
 
 array - An array of boolean to iterate
 
 Returns:
 
 A new Stream wrapping the iterator for the array as a List.
 - next
```
public T next()
```
 Specified by:
 
 next in interface Iterator<T>
 - hasNext
```
public boolean hasNext()
```
 Specified by:
 
 hasNext in interface Iterator<T>
 - remove
```
public void remove()
```
 Specified by:
 
 remove in interface Iterator<T>

Class Stream<T>

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface java.util.Iterator

Method Detail

filter

filter

filterWithIndex

filterWithIndex

concat

skip

flatMap

flatMap

flatMapWithIndex

flatMapWithIndex

tap

tap

tapEvery

tapEvery

tapWithIndex

tapWithIndex

tapEveryWithIndex

tapEveryWithIndex

map

map

mapWithIndex

mapWithIndex

until

until

untilWithIndex

untilWithIndex

collate

collate

collate

collate

zip

zip

zip

zip

zipWithIndex

zipWithIndex

zipWithIndex

zipWithIndex

repeat

repeat

take

from

from

from

from

from

from

from

from

from

from

from

from

from

from

from

from

from

from

next

hasNext

remove