|
Scala 2.2.0
|
abstract
trait
Iterator
[A]
extends
java.lang.Object with
scala.ScalaObjecthasNext
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.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
[A <: B]
(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
[A <: B]
(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
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
append
[A <: B](that: scala.Iterator[B]): java.lang.Object with scala.Iterator[B]
that
.
def
buffered
: scala.BufferedIterator[A]
def
contains
(elem: scala.Any): scala.Boolean
elem
is a member of this list.elem -
element whose membership has to be tested.
==
) to elem
.
def
copyToArray
[A <: B](xs: scala.Array[B], start: scala.Int): scala.Array[B]
xs
with the elements of
this sequence starting at position start
.xs -
the array to fill.
start -
starting index.
xs
filled with the elements of this iterator.
@pre The array must be large enough to hold all elements.
def
counted
: java.lang.Object with scala.CountedIterator[A]
def
drop
(n: scala.Int): scala.Iterator[A]
n
elements from this iterator.
def
duplicate
: scala.Tuple2[scala.Iterator[A],scala.Iterator[A]]
def
exists
(p: (A) => scala.Boolean): scala.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
filter
(p: (A) => scala.Boolean): scala.Iterator[A]
p
. The order of the elements
is preserved.p -
the predicate used to filter the iterator.
p
.
def
find
(p: (A) => scala.Boolean): scala.Option[A]
p -
the predicate
p
, or None
if none exists.
def
flatMap
[B](f: (A) => scala.Iterator[B]): scala.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
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
forall
(p: (A) => scala.Boolean): scala.Boolean
p
to all elements of this
iterable object and return true, iff the predicate yields
true for all elements.p -
the predicate
def
foreach
(f: (A) => scala.Unit): scala.Unit
f
to all elements of this
iterable object.f -
a function that is applied to every element.
abstract
def
hasNext
: scala.Boolean
def
map
[B](f: (A) => B): scala.Iterator[B]
f
.
abstract
def
next
: A
def
take
(n: scala.Int): java.lang.Object with scala.Iterator[A]
n
elements.
def
toList
: scala.List[A]
def
zip
[B](that: scala.Iterator[B]): java.lang.Object with scala.Iterator[scala.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
zipWithIndex
: java.lang.Object with scala.Iterator[scala.Tuple2[A,scala.Int]]
-
start
the index of the first element
(a0,0), (a0,1)...
where ai
are the elements from this iterator.