scala-library 2.7.1 API : scala.Iterator

scala.Iterator

trait Iterator

trait Iterator[+ A]


        

 extends
        ScalaObject

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

Companion: Iterator

Source: Iterator.scala(204)

Direct Known Subclasses

MatchIterator, Source, BufferedIterator, MutableIterator, CountedIterator, SimpleTokenizer, XMLEventReader, CharInputStreamIterator,

Nested Classes

PredicatedIterator, TakeWhileIterator,

Fields

buffered	`def buffered` Returns a buffered iterator from this iterator	BufferedIterator[A]
counted	`def counted` Returns a counted iterator from this iterator	CountedIterator[A]
hasNext	`abstract def hasNext` Does this iterator provide another element?	Boolean
toList	`def toList` Transform this iterator into a list of all elements [details] return - a list which enumerates all elements of this iterator.	List[A]

Methods

!=	`final def !=(arg0 : Object)`	Boolean	AnyRef
!=	`final def !=(arg0 : Any)`	Boolean	Any
++	`def ++[B >: A](that : => Iterator[B])` Returns a new iterator that first yields the elements of this iterator followed by the elements provided by iterator `that`	Iterator[B]
/:	`def /:[B](z : B)(op : (B, A) => B)` Similar to `foldLeft` but can be used as an operator with the order of iterator and zero arguments reversed [details] That is, `z /: xs` is the same as `xs foldLeft z`. param `op` - the applied operator. `z` - the left argument of the first application of `op` (evaluation occurs from left to right). return - the result value see - `foldLeft`.	B
:\	`def :\[B](z : B)(op : (A, B) => B)` An alias for `foldRight` [details] That is, `xs :\ z` is the same as `xs foldRight z`. param `op` - the applied operator. `z` - the right argument of the first application of `op` (evaluation occurs from right to left). return - the result value. see - `foldRight`.	B
==	`final def ==(arg0 : Any)`	Boolean	Any
==	`final def ==(arg0 : Object)`	Boolean	AnyRef
addString	`def addString(buf : StringBuilder, start : String, sep : String, end : String)` Write all elements of this string into given string builder [details] param `end` - the ending string `start` - the starting string `sep` - the separator string `buf` - ... return - ...	StringBuilder
append	`def append[B >: A](that : Iterator[B])` Returns a new iterator that first yields the elements of this iterator followed by the elements provided by iterator `that` [details] deprecated - use `++`	Iterator[B]
asInstanceOf	`final def asInstanceOf[T0]`	T0	Any
clone	`protected def clone`	Object	AnyRef
contains	`def contains(elem : Any)` Tests if the given value `elem` is a member of this iterator [details] param `elem` - element whose membership has to be tested. return - `true` iff there is an element of this iterator which is equal (w.r.t. `==`) to `elem`.	Boolean
copyToArray	`def copyToArray[B >: A](xs : Array[B], start : Int)` Fills the given array `xs` with the elements of this sequence starting at position `start` [details] param `start` - the starting index. `xs` - the array to fill. pre - the array must be large enough to hold all elements.	Unit
copyToBuffer	`def copyToBuffer[B >: A](dest : Buffer[B])` Copy all elements to a buffer [details] param `The` - buffer to which elements are copied return - The buffer to which elements are copied	Unit
drop	`def drop(n : Int)` Removes the first `n` elements from this iterator [details] param `n` - the number of elements to drop return - the new iterator	Iterator[A]
dropWhile	`def dropWhile(p : (A) => Boolean)` Skips longest sequence of elements of this iterator which satisfy given predicate `p`, and returns an iterator of the remaining elements [details] param `p` - the predicate used to skip elements. return - an iterator consisting of the remaining elements	Iterator[A]
duplicate	`def duplicate` Creates two new iterators that both iterate over the same elements than this iterator (in the same order) [details] return - a pair of iterators	(Iterator[A], Iterator[A])
eq	`final def eq(arg0 : Object)`	Boolean	AnyRef
equals	`def equals(arg0 : Any)`	Boolean	AnyRef
exists	`def exists(p : (A) => 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` [details] param `p` - the predicate return - `true` iff the predicate yields `true` for at least one element.	Boolean
filter	`def filter(p : (A) => Boolean)` Returns an iterator over all the elements of this iterator that satisfy the predicate `p` [details] The order of the elements is preserved. param `p` - the predicate used to filter the iterator. return - the elements of this iterator satisfying `p`.	Iterator[A]
finalize	`protected def finalize`	Unit	AnyRef
find	`def find(p : (A) => Boolean)` Find and return the first element of the iterable object satisfying a predicate, if any [details] param `p` - the predicate return - the first element in the iterable object satisfying `p`, or `None` if none exists.	Option[A]
flatMap	`def flatMap[B](f : (A) => Iterator[B])` Applies the given function `f` to each element of this iterator, then concatenates the results [details] param `f` - the function to apply on each element. return - an iterator over `f(a₀), ... , f(a_n)` if this iterator yields the elements `a₀, ..., a_n`.	Iterator[B]
foldLeft	`def foldLeft[B](z : B)(op : (B, A) => B)` Combines the elements of this iterator together using the binary operator `op`, from left to right, and starting with the value `z` [details] return - `op(... (op(op(z,a₀),a₁) ...), a_n)` if the iterator yields elements `a₀, a₁, ..., a_n`.	B
foldRight	`def foldRight[B](z : B)(op : (A, B) => B)` Combines the elements of this iterator together using the binary operator `op`, from right to left, and starting with the value `z` [details] return - `a₀ op (... op (a_n op z)...)` if the iterator yields elements `a₀, a₁, ..., a_n`.	B
forall	`def forall(p : (A) => Boolean)` Apply a predicate `p` to all elements of this iterable object and return `true` iff the predicate yields `true` for all elements [details] param `p` - the predicate return - `true` iff the predicate yields `true` for all elements.	Boolean
foreach	`def foreach(f : (A) => Unit)` Apply a function `f` to all elements of this iterable object [details] param `f` - a function that is applied to every element.	Unit
getClass	`final def getClass`	Class[Any]	AnyRef
hashCode	`def hashCode`	Int	AnyRef
isInstanceOf	`final def isInstanceOf[T0]`	Boolean	Any
map	`def map[B](f : (A) => B)` Returns a new iterator that maps all elements of this iterator to new elements using function `f`	Iterator[B]
mkString	`def mkString(sep : String)` Returns a string representation of this iterable object [details] The string representations of elements (w.r.t. the method `toString()`) are separated by the string `sep`. param `sep` - separator string. return - a string representation of this iterable object.	String
mkString	`def mkString(start : String, sep : String, end : String)` Returns a string representation of the elements in this iterator [details] The resulting string begins with the string `start` and is finished by the string `end`. Inside, the string representations of elements (w.r.t. the method `toString()`) are separated by the string `sep`. Ex: `List(1, 2, 3).mkString("(", "; ", ")") = "(1; 2; 3)"` param `sep` - separator string. `end` - ending string. `start` - starting string. return - a string representation of this iterable object.	String
ne	`final def ne(arg0 : Object)`	Boolean	AnyRef
next	`abstract def next` Returns the next element	A
notify	`final def notify`	Unit	AnyRef
notifyAll	`final def notifyAll`	Unit	AnyRef
readInto	`def readInto[B >: A](xs : Array[B], start : Int)`	Unit
readInto	`def readInto[B >: A](xs : Array[B], start : Int, sz : Int)` Fills the given array `xs` with the elements of this sequence starting at position `start` [details] Like `copyToArray`, but designed to accomodate IO stream operations. param `start` - the starting index. `sz` - the maximum number of elements to be read. `xs` - the array to fill. pre - the array must be large enough to hold `sz` elements.	Unit
readInto	`def readInto[B >: A](xs : Array[B])`	Unit
reduceLeft	`def reduceLeft[B >: A](op : (B, A) => B)` Combines the elements of this iterator together using the binary operator `op`, from left to right [details] param `op` - The operator to apply return - `op(... op(a₀,a₁), ..., a_n)` if the iterator yields elements `a₀, a₁, ..., a_n`. throws `Predef.UnsupportedOperationException` - if the iterator is empty.	B
reduceRight	`def reduceRight[B >: A](op : (A, B) => B)` Combines the elements of this iterator together using the binary operator `op`, from right to left [details] param `op` - The operator to apply return - `a₀ op (... op (a_n-1 op a_n)...)` if the iterator yields elements `a₀, a₁, ..., a_n`. throws `Predef.UnsupportedOperationException` - if the iterator is empty.	B
slice	`def slice(from : Int, until : Int)` A sub-iterator of `until - from elements starting at index from [details] param until - The index of the element following the slice from - The index of the first element of the slice`	Iterator[A]
synchronized	`final def synchronized[T0](arg0 : T0)`	T0	AnyRef
take	`def take(n : Int)` Returns a new iterator that iterates only over the first `n` elements [details] param `n` - the number of elements to take return - the new iterator	Iterator[A]
takeWhile	`def takeWhile(p : (A) => Boolean)` Returns an iterator over the longest prefix of this iterator such that all elements of the result satisfy the predicate `p` [details] The order of the elements is preserved. param `p` - the predicate used to filter the iterator. return - the longest prefix of this iterator satisfying `p`.	Iterator[A]
toString	`override def toString`	String
wait	`final def wait(arg0 : Long, arg1 : Int)`	Unit	AnyRef
wait	`final def wait`	Unit	AnyRef
wait	`final def wait(arg0 : Long)`	Unit	AnyRef
zip	`def zip[B](that : Iterator[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 [details] If one of the two iterators is longer than the other, its remaining elements are ignored. return - an iterator yielding `{a₀,b₀}, {a₁,b₁}, ...` where `a_i` are the elements from this iterator and `b_i` are the elements from iterator `that`.	Iterator[(A, B)]
zipWithIndex	`def zipWithIndex` Return an iterator that pairs each element of this iterator with its index, counting from 0 [details] param `start` - the index of the first element. return - an iterator yielding `{a₀,0}, {a₁,1}...` where `a_i` are the elements from this iterator.	Iterator[(A, Int)]

scala.Iterator trait Iterator

Direct Known Subclasses

Nested Classes

Fields

Methods

scala.Iterator

trait Iterator