Scala迭代器(Iterator)

def hasNext: Boolean

ritorna true se ci sono elementi disponibili da restituire.

def next(): A

ritorna l'elemento successivo dell'iteratore e aggiorna lo stato dell'iteratore

def ++(that: => Iterator[A]): Iterator[A]

unisci due iteratori

def ++[B >: A](that :=> GenTraversableOnce[B]): Iterator[B]

unisci due iteratori

def addString(b: StringBuilder): StringBuilder

aggiungi una stringa a StringBuilder b

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

aggiungi una stringa a StringBuilder b, specificando il separatore

def buffered: BufferedIterator[A]

converti tutti gli iteratori in BufferedIterator

def contains(elem: Any): Boolean

controlla se l'iteratore contiene l'elemento specificato

def copyToArray(xs: Array[A], start: Int, len: Int): Unit

passa i valori selezionati dell'iteratore a un array

def count(p: (A) => Boolean): Int

ritorna il numero totale di elementi dell'iteratore che soddisfano la condizione p.

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

ritorna una nuova raccolta senza i primi n elementi

def dropWhile(p: (A) => Boolean): Iterator[A]

Scarta gli elementi da sinistra a destra fino a quando la condizione p non è più soddisfatta.

def duplicate: (Iterator[A], Iterator[A])

Genera due iteratori che possono restituire rispettivamente tutti gli elementi degli iteratori.

def exists(p: (A) => Boolean): Boolean

Restituisce un valore booleano che indica se esiste un elemento nell'iteratore che soddisfa la condizione p.

def filter(p: (A) => Boolean): Iterator[A]

Restituisce un nuovo iteratore che punta agli elementi dell'iteratore che soddisfano la condizione p.

def filterNot(p: (A) => Boolean): Iterator[A]

Restituisce un iteratore che punta agli elementi dell'iteratore che non soddisfano la condizione p.

def find(p: (A) => Boolean): Option[A]

Restituisce il primo elemento che soddisfa p o None. Attenzione: se viene trovato un elemento che soddisfa la condizione, l'iteratore viene posizionato dopo quell'elemento; se non viene trovato, viene posizionato alla fine.

def flatMap[B](f: (A) => GenTraversableOnce[B]): Iterator[B]

Applica la funzione f a ogni elemento della sequenza dell'iteratore e restituisce un iteratore che punta alla sequenza dei risultati.

def forall(p: (A) => Boolean): Boolean

Restituisce un valore booleano che indica se tutti gli elementi a cui si riferisce it soddisfano la condizione p.

def foreach(f: (A) => Unit): Unit

Esegui il programma specificato f su ogni elemento restituito dall'iteratore.

def hasDefiniteSize: Boolean

Restituisce true se il numero di elementi dell'iteratore è finito (equivale a isEmpty per default).

def indexOf(elem: B): Int

Restituisce il primo elemento dell'iteratore con l'indice uguale a x. Attenzione: l'iteratore supera questo elemento.

def indexWhere(p: (A) => Boolean): Int

Restituisce l'elemento dell'iteratore che ha l'indice soddisfacente la condizione p. Attenzione: l'iteratore supera questo elemento.

def isEmpty: Boolean

Controlla se it è vuoto, se lo è restituisce true, altrimenti restituisce false (contrario di hasNext).

def isTraversableAgain: Boolean

Verifica se questo Iterator può essere percorso ripetutamente.

def length: Int

Restituisce il numero di elementi dell'iteratore.

def map[B](f: (A) => B): Iterator[B]

Passa ogni elemento di it al funzione f e genera un nuovo iteratore con i risultati.

def max: A

Restituisce l'elemento più grande degli elementi dell'iteratore.

def min: A

Restituisce l'elemento più piccolo degli elementi dell'iteratore.

def mkString: String

Converti tutti gli elementi dell'iteratore in una stringa.

def mkString(sep: String): String

Converti tutti gli elementi dell'iteratore in una stringa, specificando il separatore.

def nonEmpty: Boolean

Verifica se il contenitore contiene l'elemento (equivalente a hasNext).

def padTo(len: Int, elem: A): Iterator[A]

Restituisce un iteratore che contiene tutti gli elementi dell'iteratore e aggiunge copie di elem fino a raggiungere la lunghezza len.

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

Restituisce un nuovo iteratore in cui gli elementi replacements a partire dal elemento di posizione from vengono sostituiti dagli elementi dell'iteratore.

def product: A

Restituisce il prodotto degli elementi numerici dell'iteratore.

def sameElements(that: Iterator[_]): Boolean

Determina se l'iteratore e l'iteratore specificato restituiscono gli elementi in modo sequenziale.

def seq: Iterator[A]

Restituisce una vista seriale della collezione.

def size: Int

Restituisce il numero di elementi dell'iteratore.

def slice(from: Int, until: Int): Iterator[A]

Restituisce un nuovo iteratore che punta a un segmento della sequenza dell'iteratore, che va dall'elemento di posizione from all'elemento di posizione until.

def sum: A

Restituisce la somma degli elementi numerici dell'iteratore.

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

Restituisce un nuovo iteratore per i primi n elementi.

def toArray: Array[A]

将迭代器指向的所有元素归入数组并返回。

def toBuffer: Buffer[B]

将迭代器指向的所有元素拷贝至缓冲区Buffer。

def toIterable: Iterable[A]

返回一个包含此可遍历或迭代器所有元素的Iterable。对于无限迭代器，此操作不会终止。

def toIterator: Iterator[A]

把迭代器的所有元素归入一个Iterator容器并返回。

def toList: List[A]

把迭代器的所有元素归入列表并返回

def toMap[T, U]: Map[T, U]

将迭代器的所有键值对归入一个Map并返回。

def toSeq: Seq[A]

将迭代器的所有元素归入一个Seq容器并返回。

def toString(): String

将迭代器转换为字符串

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

返回一个新迭代器，指向分别由迭代器和指定的迭代器that元素一一对应而成的二元组序列