|
Scala
1.4.0.3 |
|||
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.3 |
|||