in scala
trait Iterator

trait Iterator[A]()
extends Object
with ScalaObject
Implementing classes or objects:
trait BufferedIterator[A]()

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

Method 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.
  def :\[B](z: B)(f: (A,B) => B): B
     An alias for foldRight.
  def append[B >: A](that: Iterator[B]): Iterator[B]
     Returns a new iterator that first yields the elements of this iterator followed by the elements provided by iterator that.
  def buffered: BufferedIterator[A]
     Returns a buffered iterator from this iterator.
  def copyToArray[B >: A](xs: Array[B], start: Int): Array[B]
     Fills the given array xs with the elements of this sequence starting at position start.
  def drop(n: Int): Iterator[A]
     Removes the first n elements from this iterator.
  def duplicate: Tuple2[Iterator[A],Iterator[A]]
     Creates two new iterators that both iterate over the same elements than this iterator (in the same order).
  def exists(p: (A) => Boolean): 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) => Boolean): Iterator[A]
     Returns an iterator over all the elements of this iterator that satisfy the predicate p.
  def find(p: (A) => Boolean): Option[A]
     Find and return the first element of the iterable object satisfying a predicate, if any.
  def flatMap[B](f: (A) => Iterator[B]): 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) => Boolean): 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) => Unit): Unit
     Apply a function f to all elements of this iterable object.
abstract def hasNext: Boolean
     Does this iterator provide another element?
  def map[B](f: (A) => B): 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: Int): Iterator[A]
     Returns a new iterator that iterates only over the first n elements.
  def toList: List[A]
     Transform this iterator into a list of all elements.
  def zip[B](that: Iterator[B]): Iterator[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.

Methods inherited from java/lang/Object-class
clone, eq, equals, finalize, getClass, hashCode, notify, notifyAll, synchronized, toString, wait, wait, wait

Methods inherited from scala/Any-class
!=, ==, asInstanceOf, isInstanceOf, match

Method Detail

hasNext

  abstract def hasNext: Boolean
Does this iterator provide another element?

next

  abstract def next: A
Returns the next element.

take

  def take(n: Int): Iterator[A]
Returns a new iterator that iterates only over the first n elements.

drop

  def drop(n: Int): Iterator[A]
Removes the first n elements from this iterator.

map

  def map[B](f: (A) => B): Iterator[B]
Returns a new iterator that maps all elements of this iterator to new elements using function f.

append

  def append[B >: A](that: Iterator[B]): Iterator[B]
Returns a new iterator that first yields the elements of this iterator followed by the elements provided by iterator that.

flatMap

  def flatMap[B](f: (A) => Iterator[B]): 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.

filter

  def filter(p: (A) => Boolean): 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 redicate used to filter the iterator.
Returns:
the elements of this iterator satisfying p.

zip

  def zip[B](that: Iterator[B]): Iterator[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 - 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.

foreach

  def foreach(f: (A) => Unit): Unit
Apply a function f to all elements of this iterable object.
Parameters:
f - a function that is applied to every element.

forall

  def forall(p: (A) => Boolean): 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.

exists

  def exists(p: (A) => Boolean): 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.

find

  def find(p: (A) => Boolean): 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.

foldLeft

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

foldRight

  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 [a0, a1, ..., an].

/:

  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

buffered

  def buffered: BufferedIterator[A]
Returns a buffered iterator from this iterator.

duplicate

  def duplicate: Tuple2[Iterator[A],Iterator[A]]
Creates two new iterators that both iterate over the same elements than this iterator (in the same order).

copyToArray

  def copyToArray[B >: A](xs: Array[B], start: Int): Array[B]
Fills the given array xs with the elements of this sequence starting at position start.
Parameters:
xs - the array to fill.
start - starting index.
Returns:
the given array xs filled with this list.

toList

  def toList: List[A]
Transform this iterator into a list of all elements.
Returns:
a list which enumerates all elements of this iterator.