final def !=(arg0: Any): Boolean

Definition Classes: AnyRef → Any

final def ##(): Int

Definition Classes: AnyRef → Any

def ++[B >: A](xs: ⇒ IterableOnce[B]): Iterator[B]

Annotations: @inline()

final def ==(arg0: Any): Boolean

Definition Classes: AnyRef → Any

def addString(b: StringBuilder, start: String, sep: String, end: String): StringBuilder

Appends all elements of this $coll to a string builder using start, end, and separator strings.

Appends all elements of this $coll to a string builder using start, end, and separator strings. The written text begins with the string start and ends with the string end. Inside, the string representations (w.r.t. the method toString) of all elements of this $coll are separated by the string sep.

Example:

scala> val a = List(1,2,3,4)
a: List[Int] = List(1, 2, 3, 4)

scala> val b = new StringBuilder()
b: StringBuilder =

scala> a.addString(b , "List(" , ", " , ")")
res5: StringBuilder = List(1, 2, 3, 4)

b: the string builder to which elements are appended.
start: the starting string.
sep: the separator string.
end: the ending string.
returns: the string builder b to which elements were appended.

final def asInstanceOf[T0]: T0

Definition Classes: Any

def clone(): AnyRef

Attributes: protected[java.lang]
Definition Classes: AnyRef
Annotations: @throws( ... )

def collect[B](pf: PartialFunction[A, B]): Iterator[B]

Creates an iterator by transforming values produced by this iterator with a partial function, dropping those values for which the partial function is not defined.

pf: the partial function which filters and maps the iterator.
returns: a new iterator which yields each value x produced by this iterator for which pf is defined the image pf(x).

Note: Reuse: $consumesAndProducesIterator

def concat[B >: A](xs: ⇒ IterableOnce[B]): Iterator[B]

def contains(elem: Any): Boolean

Tests whether this iterator contains a given value as an element.

Tests whether this iterator contains a given value as an element. $mayNotTerminateInf

elem: the element to test.
returns: true if this iterator produces some value that is is equal (as determined by ==) to elem, false otherwise.

Note: Reuse: After calling this method, one should discard the iterator it was called on. Using it is undefined and subject to change.

def count(p: (A) ⇒ Boolean): Int

Counts the number of elements in the $coll which satisfy a predicate.

p: the predicate used to test elements.
returns: the number of elements satisfying the predicate p.

def distinct: Iterator[A]

Builds a new iterator from this one without any duplicated elements on it.

returns: iterator with distinct elements

Note: Reuse: After calling this method, one should discard the iterator it was called on. Using it is undefined and subject to change.

def distinctBy[B](f: (A) ⇒ B): Iterator[A]

Builds a new iterator from this one without any duplicated elements as determined by == after applying the transforming function f.

B: the type of the elements after being transformed by f
f: The transforming function whose result is used to determine the uniqueness of each element
returns: iterator with distinct elements

Note: Reuse: After calling this method, one should discard the iterator it was called on. Using it is undefined and subject to change.

def drop(n: Int): Iterator[A]

def dropWhile(p: (A) ⇒ Boolean): Iterator[A]

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

p: the predicate used to skip elements.
returns: an iterator consisting of the remaining elements

Note: Reuse: $consumesAndProducesIterator

final def eq(arg0: AnyRef): Boolean

Definition Classes: AnyRef

def equals(arg0: Any): Boolean

Definition Classes: AnyRef → Any

def exists(p: (A) ⇒ Boolean): Boolean

Tests whether a predicate holds for some of the values produced by this iterator.

Tests whether a predicate holds for some of the values produced by this iterator. $mayNotTerminateInf

p: the predicate used to test elements.
returns: true if the given predicate p holds for some of the values produced by this iterator, otherwise false.

Note: Reuse: After calling this method, one should discard the iterator it was called on. Using it is undefined and subject to change.

def filter(p: (A) ⇒ Boolean): Iterator[A]

Selects all elements of this iterator which satisfy a predicate.

p: the predicate used to test elements.
returns: a new iterator consisting of all elements of this $coll that satisfy the given predicate p. The order of the elements is preserved.

def filterNot(p: (A) ⇒ Boolean): Iterator[A]

Creates an iterator over all the elements of this iterator which do not satisfy a predicate p.

p: the predicate used to test values.
returns: an iterator which produces those values of this iterator which do not satisfy the predicate p.

Note: Reuse: $consumesAndProducesIterator

def finalize(): Unit

Attributes: protected[java.lang]
Definition Classes: AnyRef
Annotations: @throws( classOf[java.lang.Throwable] )

def find(p: (A) ⇒ Boolean): Option[A]

Finds the first value produced by the iterator satisfying a predicate, if any.

Finds the first value produced by the iterator satisfying a predicate, if any. $mayNotTerminateInf

p: the predicate used to test values.
returns: an option value containing the first value produced by the iterator that satisfies predicate p, or None if none exists.

Note: Reuse: After calling this method, one should discard the iterator it was called on. Using it is undefined and subject to change.

def flatMap[B](f: (A) ⇒ IterableOnce[B]): Iterator[B]

def foldLeft[B](z: B)(op: (B, A) ⇒ B): B

def foldRight[B](z: B)(op: (A, B) ⇒ B): B

def forall(p: (A) ⇒ Boolean): Boolean

Tests whether a predicate holds for all values produced by this iterator.

Tests whether a predicate holds for all values produced by this iterator. $mayNotTerminateInf

p: the predicate used to test elements.
returns: true if the given predicate p holds for all values produced by this iterator, otherwise false.

Note: Reuse: After calling this method, one should discard the iterator it was called on. Using it is undefined and subject to change.

def foreach[U](f: (A) ⇒ U): Unit

final def getClass(): Class[_]

Definition Classes: AnyRef → Any

def grouped[B >: A](size: Int): GroupedIterator[B]

Returns an iterator which groups this iterator into fixed size blocks.

Returns an iterator which groups this iterator into fixed size blocks. Example usages:

// Returns List(List(1, 2, 3), List(4, 5, 6), List(7)))
(1 to 7).iterator grouped 3 toList
// Returns List(List(1, 2, 3), List(4, 5, 6))
(1 to 7).iterator grouped 3 withPartial false toList
// Returns List(List(1, 2, 3), List(4, 5, 6), List(7, 20, 25)
// Illustrating that withPadding's argument is by-name.
val it2 = Iterator.iterate(20)(_ + 5)
(1 to 7).iterator grouped 3 withPadding it2.next toList

Note: Reuse: $consumesAndProducesIterator

def hashCode(): Int

Definition Classes: AnyRef → Any

def indexOf[B >: A](elem: B, from: Int): Int

Returns the index of the first occurrence of the specified object in this iterable object after or at some start index.

Returns the index of the first occurrence of the specified object in this iterable object after or at some start index. $mayNotTerminateInf

elem: element to search for.
from: the start index
returns: the index >= from of the first occurrence of elem in the values produced by this iterator, or -1 if such an element does not exist until the end of the iterator is reached.

Note: Reuse: After calling this method, one should discard the iterator it was called on. Using it is undefined and subject to change.

def indexOf[B >: A](elem: B): Int

Returns the index of the first occurrence of the specified object in this iterable object.

Returns the index of the first occurrence of the specified object in this iterable object. $mayNotTerminateInf

elem: element to search for.
returns: the index of the first occurrence of elem in the values produced by this iterator, or -1 if such an element does not exist until the end of the iterator is reached.

Note: Reuse: After calling this method, one should discard the iterator it was called on. Using it is undefined and subject to change.

def indexWhere(p: (A) ⇒ Boolean, from: Int = 0): Int

def isEmpty: Boolean

Tests whether this iterator is empty.

returns: true if hasNext is false, false otherwise.

Note: Reuse: $preservesIterator

final def isInstanceOf[T0]: Boolean

Definition Classes: Any

def iterator(): Iterator[A]

Iterator can be used only once

Definition Classes: Iterator → IterableOnce

final def knownSize: Int

Definition Classes: Iterator → IterableOnce

def length: Int

def map[B](f: (A) ⇒ B): Iterator[B]

def mkString: String

def mkString(sep: String): String

def mkString(start: String, sep: String, end: String): String

final def ne(arg0: AnyRef): Boolean

Definition Classes: AnyRef

def nextOption(): Option[A]

Wraps the value of next() in an option.

returns: Some(next) if a next element exists, None otherwise.

final def notify(): Unit

Definition Classes: AnyRef

final def notifyAll(): Unit

Definition Classes: AnyRef

def patch[B >: A](from: Int, patchElems: Iterator[B], replaced: Int): Iterator[B]

Returns this iterator with patched values.

Returns this iterator with patched values. Patching at negative indices is the same as patching starting at 0. Patching at indices at or larger than the length of the original iterator appends the patch to the end. If more values are replaced than actually exist, the excess is ignored.

from: The start index from which to patch
patchElems: The iterator of patch values
replaced: The number of values in the original iterator that are replaced by the patch.

Note: Reuse: $consumesTwoAndProducesOneIterator

def sameElements[B >: A](that: IterableOnce[B]): Boolean

def scanLeft[B](z: B)(op: (B, A) ⇒ B): Iterator[B]

Produces a collection containing cumulative results of applying the operator going left to right.

$willNotTerminateInf $orderDependent

B: the type of the elements in the resulting collection
z: the initial value
op: the binary operator applied to the intermediate result and the element
returns: iterator with intermediate results

Note: Reuse: $consumesAndProducesIterator

final def size: Int

def sliding[B >: A](size: Int, step: Int = 1): GroupedIterator[B]

Returns an iterator which presents a "sliding window" view of this iterator.

Returns an iterator which presents a "sliding window" view of this iterator. The first argument is the window size, and the second argument step is how far to advance the window on each iteration. The step defaults to 1.

The default GroupedIterator can be configured to either pad a partial result to size size or suppress the partial result entirely.

Example usages:

// Returns List(List(1, 2, 3), List(2, 3, 4), List(3, 4, 5))
(1 to 5).iterator.sliding(3).toList
// Returns List(List(1, 2, 3, 4), List(4, 5))
(1 to 5).iterator.sliding(4, 3).toList
// Returns List(List(1, 2, 3, 4))
(1 to 5).iterator.sliding(4, 3).withPartial(false).toList
// Returns List(List(1, 2, 3, 4), List(4, 5, 20, 25))
// Illustrating that withPadding's argument is by-name.
val it2 = Iterator.iterate(20)(_ + 5)
(1 to 5).iterator.sliding(4, 3).withPadding(it2.next).toList

returns: An iterator producing Seq[B]s of size size, except the last element (which may be the only element) will be truncated if there are fewer than size elements remaining to be grouped. This behavior can be configured.

Note: Reuse: $consumesAndProducesIterator

final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes: AnyRef

def take(n: Int): Iterator[A]

def takeWhile(p: (A) ⇒ Boolean): Iterator[A]

Takes longest prefix of values produced by this iterator that satisfy a predicate.

p: The predicate used to test elements.
returns: An iterator returning the values produced by this iterator, until this iterator produces a value that does not satisfy the predicate p.

Note: Reuse: $consumesAndProducesIterator

def to[C](factory: Factory[A, C]): C

Converts this Iterator into another collection.

C: The collection type to build.
factory: Collection factory to use. The factory may or may not eagerly consume this iterator.
returns: a new collection containing all elements of this Iterator.

def toString(): String

Definition Classes: AnyRef → Any

final def wait(): Unit

Definition Classes: AnyRef
Annotations: @throws( ... )

final def wait(arg0: Long, arg1: Int): Unit

Definition Classes: AnyRef
Annotations: @throws( ... )

final def wait(arg0: Long): Unit

Definition Classes: AnyRef
Annotations: @throws( ... )

def withFilter(p: (A) ⇒ Boolean): Iterator[A]

Creates an iterator over all the elements of this iterator that satisfy the predicate p.

Creates an iterator over all the elements of this iterator that satisfy the predicate p. The order of the elements is preserved.

Note: withFilter is the same as filter on iterators. It exists so that for-expressions with filters work over iterators.

p: the predicate used to test values.
returns: an iterator which produces those values of this iterator which satisfy the predicate p.

Note: Reuse: $consumesAndProducesIterator

def zip[B](that: IterableOnce[B]): Iterator[(A, B)]

def zipWithIndex: Iterator[(A, Int)]

Creates an iterator that pairs each element produced by this iterator with its index, counting from 0.

returns: a new iterator containing pairs consisting of corresponding elements of this iterator and their indices.

Note: Reuse: $consumesAndProducesIterator

Packages

Iterator

Companion object Iterator

trait Iterator[+A] extends IterableOnce[A]

Type Members

Abstract Value Members

Concrete Value Members

Inherited from IterableOnce[A]

Inherited from AnyRef

Inherited from Any

Ungrouped