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, MutableIterator, CountedIterator, BufferedIterator

Def Summary
| `def` ++ [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` /: [B] (z: B)(op: (B, A) => B) : B Similar to `foldLeft` but can be used as an operator with the order of iterator and zero arguments reversed. That is, `z /: xs` is the same as `xs foldLeft z`.
| `def` :\ [B] (z: B)(op: (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 iterator.
| `def` copyToArray [B >: A] (xs: scala.Array[B], start: scala.Int) : scala.Unit Fills the given array `xs` with the elements of this sequence starting at position `start`.
| `def` copyToBuffer [B >: A] (dest: scala.collection.mutable.Buffer[B]) : scala.Unit Copy all elements to a buffer
| `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` dropWhile (p: (A) => scala.Boolean) : scala.Iterator[A] Skips longest sequence of elements of this iterator which satisfy given predicate `p`, and returns an iterator of the remaining elements.
| `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 iterator 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 iterator together using the binary operator `op`, from right 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` reduceLeft [B >: A] (op: (B, B) => B) : B Combines the elements of this iterator together using the binary operator `op`, from left to right
| `def` reduceRight [B >: A] (op: (B, B) => B) : B Combines the elements of this iterator together using the binary operator `op`, from right to left
| `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` takeWhile (p: (A) => scala.Boolean) : scala.Iterator[A] Returns an iterator over the longest prefix of this iterator such that all elements of the result satisfy the predicate `p`. The order of the elements is preserved.
| `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[{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. If one of the two iterators is longer than the other, its remaining elements are ignored.
| `def` zipWithIndex : java.lang.Object with scala.Iterator[{A, scala.Int}] Return an iterator that pairs each element of this iterator with its index, counting from 0.

Def Detail

`def` ++ [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` /: [B](z: B)(op: (B, A) => B): B

  Similar to `foldLeft` but can be used as an operator with the order of iterator 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 `op` (evaluation occurs from left to right).
Parameters:
  `op -` the applied operator.
Returns:
  the result value
See Also:
  `foldLeft`.

`def` :\ [B](z: B)(op: (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 `op` (evaluation occurs from right to left).
Parameters:
  `op -` the applied operator.
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`.

Deprecated:
  use `++`

`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 iterator.

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

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

  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.
Precondition:
  the array must be large enough to hold all elements.

`def` copyToBuffer [B >: A](dest: scala.collection.mutable.Buffer[B]): scala.Unit

  Copy all elements to a buffer

Parameters:
  `The -` buffer to which elements are copied
Returns:
  The buffer to which elements are copied

`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.

Parameters:
  `n -` the number of elements to drop
Returns:
  the new iterator

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

  Skips longest sequence of elements of this iterator which satisfy given predicate `p`, and returns an iterator of the remaining elements.

Parameters:
  `p -` the predicate used to skip elements.
Returns:
  an iterator consisting of the remaining elements

`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 iterator 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 iterator yields elements `a0, a1, ..., an`.

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

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

Returns:
  `a0 op (... op (an op z)...)` if the iterator yields elements `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` reduceLeft [B >: A](op: (B, B) => B): B

  Combines the elements of this iterator together using the binary operator `op`, from left to right

Parameters:
  `op -` The operator to apply
Returns:
  `op(... op(a0,a1), ..., an)` if the iterator yields elements `a0, a1, ..., an`.
Throws:
  `Predef.UnsupportedOperationException -` if the iterator is empty.

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

  Combines the elements of this iterator together using the binary operator `op`, from right to left

Parameters:
  `op -` The operator to apply
Returns:
  `a0 op (... op (an-1 op an)...)` if the iterator yields elements `a0, a1, ..., an`.
Throws:
  `Predef.UnsupportedOperationException -` if the iterator is empty.

`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 number of elements to take
Returns:
  the new iterator

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

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

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

`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[{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. If one of the two iterators is longer than the other, its remaining elements are ignored.

Returns:
  an iterator yielding `{a0,b0}, {a1,b1}, ...` where `ai` are the elements from this iterator and `bi` are the elements from iterator `that`.

`def` zipWithIndex : java.lang.Object with scala.Iterator[{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}, {a1,1}...` where `ai` are the elements from this iterator.