in scala
trait Iterator

`abstract trait` Iterator [A]
  `extends` java.lang.Object
  `with` scala.ScalaObject

  Iterators are data structures that allow to iterate over a sequence of elements. They have a `hasNext` method for checking if there is a next element available, and a `next` method which returns the next element and discards it from the iterator.

Author:
  Martin Odersky, Matthias Zenger
Version:
  1.2, 15/03/2004

Direct Known Subclasses:
  XMLEventReader, SimpleTokenizer, CharInputStreamIterator, Source, CountedIterator, BufferedIterator

Def Summary
| `def` /: [B] (z: B)(f: (B, A) => B) : B Similar to `foldLeft` but can be used as an operator with the order of list and zero arguments reversed. That is, `z /: xs` is the same as `xs foldLeft z`.
| `def` :\ [B] (z: B)(f: (A, B) => B) : B An alias for `foldRight`. That is, `xs :\ z` is the same as `xs foldRight z`.
| `def` append [B >: A] (that: scala.Iterator[B]) : java.lang.Object with scala.Iterator[B] Returns a new iterator that first yields the elements of this iterator followed by the elements provided by iterator `that`.
| `def` buffered : scala.BufferedIterator[A] Returns a buffered iterator from this iterator.
| `def` contains (elem: scala.Any) : scala.Boolean Tests if the given value `elem` is a member of this list.
| `def` copyToArray [B >: A] (xs: scala.Array[B], start: scala.Int) : scala.Array[B] Fills the given array `xs` with the elements of this sequence starting at position `start`.
| `def` counted : java.lang.Object with scala.CountedIterator[A] Returns a counted iterator from this iterator.
| `def` drop (n: scala.Int) : scala.Iterator[A] Removes the first `n` elements from this iterator.
| `def` duplicate : scala.Tuple2[scala.Iterator[A], scala.Iterator[A]] Creates two new iterators that both iterate over the same elements than this iterator (in the same order).
| `def` exists (p: (A) => scala.Boolean) : scala.Boolean Apply a predicate `p` to all elements of this iterable object and return true, iff there is at least one element for which `p` yields `true`.
| `def` filter (p: (A) => scala.Boolean) : scala.Iterator[A] Returns an iterator over all the elements of this iterator that satisfy the predicate `p`. The order of the elements is preserved.
| `def` find (p: (A) => scala.Boolean) : scala.Option[A] Find and return the first element of the iterable object satisfying a predicate, if any.
| `def` flatMap [B] (f: (A) => scala.Iterator[B]) : scala.Iterator[B] Applies the given function `f` to each element of this iterator, then concatenates the results.
| `def` foldLeft [B] (z: B)(op: (B, A) => B) : B Combines the elements of this list together using the binary operator `op`, from left to right, and starting with the value `z`.
| `def` foldRight [B] (z: B)(op: (A, B) => B) : B Combines the elements of this list together using the binary operator `op`, from rigth to left, and starting with the value `z`.
| `def` forall (p: (A) => scala.Boolean) : scala.Boolean Apply a predicate `p` to all elements of this iterable object and return `true` iff the predicate yields `true` for all elements.
| `def` foreach (f: (A) => scala.Unit) : scala.Unit Apply a function `f` to all elements of this iterable object.
`abstract` | `def` hasNext : scala.Boolean Does this iterator provide another element?
| `def` map [B] (f: (A) => B) : scala.Iterator[B] Returns a new iterator that maps all elements of this iterator to new elements using function `f`.
`abstract` | `def` next : A Returns the next element.
| `def` take (n: scala.Int) : java.lang.Object with scala.Iterator[A] Returns a new iterator that iterates only over the first `n` elements.
| `def` toList : scala.List[A] Transform this iterator into a list of all elements.
| `def` zip [B] (that: scala.Iterator[B]) : java.lang.Object with scala.Iterator[scala.Tuple2[A,B]] Return an iterator formed from this iterator and the specified iterator `that` by associating each element of the former with the element at the same position in the latter.
| `def` zipWithIndex : java.lang.Object with scala.Iterator[scala.Tuple2[A,scala.Int]] Return an iterator that pairs each element of this iterator with its index, counting from 0.

Def Detail

`def` /: [B](z: B)(f: (B, A) => B): B

  Similar to `foldLeft` but can be used as an operator with the order of list and zero arguments reversed. That is, `z /: xs` is the same as `xs foldLeft z`.

Parameters:
  `z -` the left argument of the first application of `f` (evaluation occurs from left to right).
Parameters:
  `f -` the applied function.
Returns:
  the result value
See Also:
  `foldLeft`.

`def` :\ [B](z: B)(f: (A, B) => B): B

  An alias for `foldRight`. That is, `xs :\ z` is the same as `xs foldRight z`.

Parameters:
  `z -` the right argument of the first application of `f` (evaluation occurs from right to left).
Parameters:
  `f -` the applied function.
Returns:
  the result value.
See Also:
  `foldRight`.

`def` append [B >: A](that: scala.Iterator[B]): java.lang.Object with scala.Iterator[B]

  Returns a new iterator that first yields the elements of this iterator followed by the elements provided by iterator `that`.

`def` buffered : scala.BufferedIterator[A]

  Returns a buffered iterator from this iterator.

`def` contains (elem: scala.Any): scala.Boolean

  Tests if the given value `elem` is a member of this list.

Parameters:
  `elem -` element whose membership has to be tested.
Returns:
  `true` iff there is an element of this list which is equal (w.r.t. `==`) to `elem`.

`def` copyToArray [B >: A](xs: scala.Array[B], start: scala.Int): scala.Array[B]

  Fills the given array `xs` with the elements of this sequence starting at position `start`.

Parameters:
  `xs -` the array to fill.
Parameters:
  `start -` the starting index.
Returns:
  the given array `xs` filled with the elements of this iterator.
Precondition:
  the array must be large enough to hold all elements.

`def` counted : java.lang.Object with scala.CountedIterator[A]

  Returns a counted iterator from this iterator.

`def` drop (n: scala.Int): scala.Iterator[A]

  Removes the first `n` elements from this iterator.

`def` duplicate : scala.Tuple2[scala.Iterator[A], scala.Iterator[A]]

  Creates two new iterators that both iterate over the same elements than this iterator (in the same order).

Returns:
  a pair of iterators

`def` exists (p: (A) => scala.Boolean): scala.Boolean

  Apply a predicate `p` to all elements of this iterable object and return true, iff there is at least one element for which `p` yields `true`.

Parameters:
  `p -` the predicate
Returns:
  `true` iff the predicate yields `true` for at least one element.

`def` filter (p: (A) => scala.Boolean): scala.Iterator[A]

  Returns an iterator over all the elements of this iterator that satisfy the predicate `p`. The order of the elements is preserved.

Parameters:
  `p -` the predicate used to filter the iterator.
Returns:
  the elements of this iterator satisfying `p`.

`def` find (p: (A) => scala.Boolean): scala.Option[A]

  Find and return the first element of the iterable object satisfying a predicate, if any.

Parameters:
  `p -` the predicate
Returns:
  the first element in the iterable object satisfying `p`, or `None` if none exists.

`def` flatMap [B](f: (A) => scala.Iterator[B]): scala.Iterator[B]

  Applies the given function `f` to each element of this iterator, then concatenates the results.

Parameters:
  `f -` the function to apply on each element.
Returns:
  an iterator over `f(a0), ... , f(an)` if this iterator yields the elements `a0, ..., an`.

`def` foldLeft [B](z: B)(op: (B, A) => B): B

  Combines the elements of this list together using the binary operator `op`, from left to right, and starting with the value `z`.

Returns:
  `op(... (op(op(z,a0),a1) ...), an)` if the list is `List(a0, a1, ..., an)`.

`def` foldRight [B](z: B)(op: (A, B) => B): B

  Combines the elements of this list together using the binary operator `op`, from rigth to left, and starting with the value `z`.

Returns:
  `a0 op (... op (an op z)...)` if the list is `List(a0, a1, ..., an)`.

`def` forall (p: (A) => scala.Boolean): scala.Boolean

  Apply a predicate `p` to all elements of this iterable object and return `true` iff the predicate yields `true` for all elements.

Parameters:
  `p -` the predicate
Returns:
  `true` iff the predicate yields `true` for all elements.

`def` foreach (f: (A) => scala.Unit): scala.Unit

  Apply a function `f` to all elements of this iterable object.

Parameters:
  `f -` a function that is applied to every element.

`abstract def` hasNext : scala.Boolean

  Does this iterator provide another element?

`def` map [B](f: (A) => B): scala.Iterator[B]

  Returns a new iterator that maps all elements of this iterator to new elements using function `f`.

`abstract def` next : A

  Returns the next element.

`def` take (n: scala.Int): java.lang.Object with scala.Iterator[A]

  Returns a new iterator that iterates only over the first `n` elements.

Parameters:
  `n -` the first `n` elements of the iterator
Returns:
  the new iterator

`def` toList : scala.List[A]

  Transform this iterator into a list of all elements.

Returns:
  a list which enumerates all elements of this iterator.

`def` zip [B](that: scala.Iterator[B]): java.lang.Object with scala.Iterator[scala.Tuple2[A,B]]

  Return an iterator formed from this iterator and the specified iterator `that` by associating each element of the former with the element at the same position in the latter.

Parameters:
  `that -` list `that` must have the same number of elements as this iterator.
Returns:
  an iterator yielding `(a0,b0), ..., (an,bn)` where `ai` are the elements from this iterator and `bi` are the elements from iterator `that`.

`def` zipWithIndex : java.lang.Object with scala.Iterator[scala.Tuple2[A,scala.Int]]

  Return an iterator that pairs each element of this iterator with its index, counting from 0.

Parameters:
  `start -` the index of the first element.
Returns:
  an iterator yielding `(a0,0), (a0,1)...` where `ai` are the elements from this iterator.