迭代器Iterator Scala

def hasNext: Boolean

Retourner true si il y a encore des éléments à renvoyer.

def next(): A

Retourner l'élément suivant de l'itérateur et mettre à jour l'état de l'itérateur

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

Fusionner deux itérateurs

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

Fusionner deux itérateurs

def addString(b: StringBuilder): StringBuilder

Ajouter une chaîne de caractères à StringBuilder b

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

Ajouter une chaîne de caractères à StringBuilder b, et spécifier le séparateur

def buffered: BufferedIterator[A]

Tous les itérateurs sont convertis en BufferedIterator

def contains(elem: Any): Boolean

Vérifier si l'itérateur contient l'élément spécifié

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

Transmet les valeurs sélectionnées de l'itérateur à un tableau.

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

Retourne le nombre total d'éléments de l'itérateur qui satisfont la condition p.

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

Retourne un nouveau ensemble avec les n premiers éléments délaissés.

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

Délaisse les éléments de gauche à droite jusqu'à ce que la condition p ne soit plus valable.

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

Génère deux itérateurs qui peuvent retourner tous les éléments de l'itérateur.

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

Retourne une valeur booléenne indiquant si l'itérateur contient un élément satisfaisant p.

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

Retourne un nouvel itérateur pointant vers tous les éléments de l'itérateur qui satisfont la condition p.

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

Retourne un itérateur pointant vers les éléments de l'itérateur qui ne satisfont pas la condition p.

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

Retourne le premier élément satisfaisant p ou None. Note : si un élément satisfaisant la condition est trouvé, l'itérateur est placé après cet élément ; sinon, il est placé à la fin.

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

Applique la fonction f à chaque élément de la séquence de l'itérateur et retourne un itérateur pointant vers la séquence de résultats.

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

Retourne une valeur booléenne indiquant si tous les éléments pointés par it satisfont p.

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

Exécute la programme spécifiée sur chaque élément retourné par l'itérateur.

def hasDefiniteSize: Boolean

Retourne true si le nombre d'éléments de l'itérateur est limité (par défaut équivalent à isEmpty)

def indexOf(elem: B): Int

Retourne le premier élément de l'itérateur whose index equals x. Note : l'itérateur passe au-delà de cet élément.

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

Retourne l'élément de l'itérateur whose index satisfies the condition p. Note : l'itérateur passe au-delà de cet élément.

def isEmpty: Boolean

Vérifie si it est vide, renvoie true s'il est vide, sinon renvoie false (l'inverse de hasNext).

def isTraversableAgain: Boolean

Teste si cet itérateur peut être traversé plusieurs fois.

def length: Int

Renvoie le nombre d'éléments de l'itérateur.

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

Renvoie un nouveau itérateur où chaque élément de it est passé à la fonction f et les résultats sont générés.

def max: A

Renvoie l'élément le plus grand des éléments itérés par l'itérateur.

def min: A

Renvoie l'élément le plus petit des éléments itérés par l'itérateur.

def mkString: String

Convertit tous les éléments de l'itérateur en chaîne de caractères.

def mkString(sep: String): String

Convertit tous les éléments de l'itérateur en chaîne de caractères, en spécifiant le séparateur.

def nonEmpty: Boolean

Vérifie si le conteneur contient l'élément (équivalent à hasNext).

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

Renvoie tous les éléments de l'itérateur, ajoute des copies de elem jusqu'à ce que la longueur atteigne len.

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

Renvoie un nouvel itérateur où les éléments de n°from à n°replaced sont remplacés par les éléments pointés par l'itérateur.

def product: A

Renvoie le produit des éléments numériques pointés par l'itérateur

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

Vérifie si l'itérateur et l'itérateur spécifié renvoient des éléments en ordre

def seq: Iterator[A]

Renvoie une vue séquentielle de la collection

def size: Int

Renvoie le nombre d'éléments de l'itérateur

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

Renvoie un nouvel itérateur, pointant sur la séquence pointée par l'itérateur, à partir de l'élément de début n°from jusqu'à l'élément de fin n°until.

def sum: A

Renvoie la somme des éléments numériques pointés par l'itérateur

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

返回前n个元素的新迭代器。

def toArray: Array[A]

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

def toBuffer: Buffer[B]

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

def toIterable: Iterable[A]

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

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元素一一对应而成的二元组序列