|
Scala
1.4.0.4 |
|||
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.
| 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 contains(elem: Any): Boolean
Tests if the given value elem is a member of this list.
|
|
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, ne, notify, notifyAll, synchronized, toString, wait, wait, wait |
| Methods inherited from scala/Any-class |
| !=, ==, asInstanceOf, isInstanceOf, match |
| Methods inherited from scala/ScalaObject-class |
| getScalaType |
| Method Detail |
abstract def hasNext: Boolean
abstract def next: A
def take(n: Int): Iterator[A]
n
elements.
def drop(n: Int): Iterator[A]
n elements from this iterator.
def map[B](f: (A) => B): Iterator[B]
f.
def append[B >: A](that: Iterator[B]): Iterator[B]
that.
def flatMap[B](f: (A) => Iterator[B]): Iterator[B]
f to each element of
this iterator, then concatenates the results.
f -
the function to apply on each element.
f(a0), ... , f(an) if this iterator
yields the elements a0, ..., an.
def filter(p: (A) => Boolean): Iterator[A]
p. The order of the elements
is preserved.
p -
the redicate used to filter the iterator.
p.
def zip[B](that: Iterator[B]): Iterator[Tuple2[A,B]]
that by associating each element of the former with
the element at the same position in the latter.
that -
must have the same number of elements as this
iterator.
(a0,b0), ..., (an,bn) where
ai are the elements from this iterator and
bi are the elements from iterator that.
def foreach(f: (A) => Unit): Unit
f to all elements of this
iterable object.
f -
a function that is applied to every element.
def forall(p: (A) => Boolean): Boolean
p to all elements of this
iterable object and return true, iff the predicate yields
true for all elements.
p -
the predicate
def exists(p: (A) => Boolean): Boolean
p to all elements of this
iterable object and return true, iff there is at least one
element for which p yields true.
p -
the predicate
def contains(elem: Any): Boolean
elem is a member of this list.
elem -
element whose membership has to be tested.
==) to elem.
def find(p: (A) => Boolean): Option[A]
p -
the predicate
p,
or None if none exists.
def foldLeft[B](z: B)(op: (B,A) => B): B
op, from left to right, and starting with
the value z. 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
op, from rigth to left, and starting with
the value z. a0 op (... op (an op z)...) if the list
is [a0, a1, ..., an].
def /:[B](z: B)(f: (B,A) => B): B
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
foldRight.
That is, xs :\ z is the same as xs foldRight z
def buffered: BufferedIterator[A]
def duplicate: Tuple2[Iterator[A],Iterator[A]]
def copyToArray[B >: A](xs: Array[B], start: Int): Array[B]
xs with the elements of
this sequence starting at position start.
xs -
the array to fill.
start -
starting index.
xs filled with this list.
def toList: List[A]
|
Scala
1.4.0.4 |
|||