Itérateur Scala
Scala Iterator n'est pas une collection ; c'est une méthode pour accéder aux collections.
Les deux opérations de base de l'itérateur it sont :nextethasNext。
Appelerit.next()renvoie l'élément suivant de l'itérateur et met à jour l'état de l'itérateur.
Appelerit.hasNext()sert à vérifier s'il y a d'autres éléments dans la collection.
La façon la plus simple de faire en sorte que l'itérateur it renvoie tous les éléments un par un est d'utiliser une boucle while :
Exemple
def main(args: Array[String]) {
val it = Iterator("Baidu", "Google", "Example", "Taobao")
while (it.hasNext){
println(it.next())
}
}
}
L'exécution du code ci-dessus produit la sortie suivante :
$ scalac Test.scala $ scala Test Baidu Google Example Taobao
Trouver les éléments max et min
Vous pouvez utiliserit.minetit.maxles méthodes pour trouver les éléments maximum et minimum de l'itérateur, comme montré dans l'exemple suivant :
Exemple
def main(args: Array[String]) {
val ita = Iterator(20,40,2,50,69, 90)
val itb = Iterator(20,40,2,50,69, 90)
println("Le plus grand élément est :" + ita.max )
println("Le plus petit élément est :" + itb.min )
}
}
L'exécution du code ci-dessus produit la sortie suivante :
$ scalac Test.scala $ scala Test 最大元素是:90 最小元素是:2
Obtenir la longueur d'un itérateur
Vous pouvez utiliserit.sizeouit.lengthles méthodes pour voir le nombre d'éléments dans l'itérateur. Les exemples sont les suivants :
Exemple
def main(args: Array[String]) {
val ita = Iterator(20,40,2,50,69, 90)
val itb = Iterator(20,40,2,50,69, 90)
println("La valeur de ita.size : " + ita.size )
println("La valeur de itb.length : " + itb.length )
}
}
L'exécution du code ci-dessus produit la sortie suivante :
$ scalac Test.scala $ scala Test ita.size 的值: 6 itb.length 的值: 6
Méthodes courantes de l'itérateur Scala
Le tableau suivant répertorie les méthodes courantes de l'itérateur Scala :
| Non. | Méthode et description |
|---|---|
| 1 |
def hasNext: Boolean Renvoie true s'il y a des éléments qui peuvent être renvoyés. |
| 2 |
def next(): A Renvoie l'élément suivant de l'itérateur et met à jour l'état de l'itérateur. |
| 3 |
def ++(that: => Iterator[A]): Iterator[A] Concatène deux itérateurs |
| 4 |
def [B > A](that :=> GenTraversableOnce[B]): Iterator[B] Concatène deux itérateurs |
| 5 |
addString(b: StringBuilder): StringBuilder Ajoute une chaîne à StringBuilder b |
| 6 |
def addString(b: StringBuilder, sep: String): StringBuilder Ajoute une chaîne à StringBuilder b, et spécifie un séparateur |
| 7 |
def buffered: BufferedIterator[A] Convertit l'itérateur en un BufferedIterator |
| 8 |
def contains(elem: Any): Boolean Vérifie si l'itérateur contient l'élément spécifié |
| 9 |
def copyToArray(xs: Array[A], start: Int, len: Int): Unit Copie les valeurs sélectionnées de l'itérateur dans un tableau |
| 10 |
def count(p: (A) => Boolean): Int Renvoie le nombre total d'éléments de l'itérateur qui satisfont la condition p. |
| 11 |
def drop(n: Int): Iterator[A] Renvoie une nouvelle collection qui supprime les n premiers éléments |
| 12 |
def dropWhile(p: (A) => Boolean): Iterator[A] Supprime des éléments de gauche à droite jusqu'à ce que la condition p soit fausse |
| 13 |
def duplicate: (Iterator[A], Iterator[A]) Génère deux itérateurs qui peuvent chacun renvoyer tous les éléments de l'itérateur. |
| 14 |
def exists(p: (A) => Boolean): Boolean Renvoie une valeur booléenne indiquant s'il existe un élément satisfaisant p parmi les éléments de l'itérateur. |
| 15 |
def filter(p: (A) => Boolean): Iterator[A] Renvoie un nouvel itérateur pointant vers tous les éléments de l'itérateur qui satisfont la condition p. |
| 16 |
def filterNot(p: (A) => Boolean): Iterator[A] Renvoie un itérateur pointant vers les éléments de l'itérateur qui ne satisfont pas la condition p. |
| 17 |
def find(p: (A) => Boolean): Option[A] Renvoie le premier élément qui satisfait p, ou None. Remarque : si un élément satisfaisant la condition est trouvé, l'itérateur est positionné après cet élément ; s'il n'est pas trouvé, il est positionné à la fin. |
| 18 |
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 renvoie un itérateur pointant vers la séquence résultante. |
| 19 |
def forall(p: (A) => Boolean): Boolean Renvoie une valeur booléenne indiquant si tous les éléments auxquels il fait référence satisfont p. |
| 20 |
def foreach(f: (A) => Unit): Unit Exécute la procédure spécifiée f sur chaque élément renvoyé par l'itérateur. |
| 21 |
def hasDefiniteSize: Boolean Renvoie true si l'itérateur possède un nombre fini d'éléments (par défaut équivalent à isEmpty) |
| 22 |
def indexOf(elem: B): Int Renvoie le premier élément de l'itérateur dont l'index est égal à x. Remarque : l'itérateur ignorera cet élément. |
| 23 |
def indexWhere(p: (A) => Boolean): Int Renvoie l'élément de l'itérateur dont l'index satisfait la condition p. Remarque : l'itérateur ignorera cet élément. |
| 24 |
def isEmpty: Boolean Vérifie s'il est vide ; renvoie true s'il est vide, sinon renvoie false (opposé de hasNext). |
| 25 |
def isTraversableAgain: Boolean Teste si cet Iterator peut être parcouru de manière répétée. |
| 26 |
def length: Int Renvoie le nombre d'éléments dans l'itérateur. |
| 27 |
def map[B](f: (A) => B): Iterator[B] Génère un nouvel itérateur à partir des résultats obtenus en passant chaque élément qu'il contient à la fonction f. |
| 28 |
def max: A Renvoie le plus grand élément parmi les éléments de l'itérateur. |
| 29 |
def min: A Renvoie le plus petit élément parmi les éléments de l'itérateur. |
| 30 |
def mkString: String Convertit tous les éléments de l'itérateur en une chaîne de caractères. |
| 31 |
def mkString(sep: String): String Convertit tous les éléments de l'itérateur en une chaîne de caractères et spécifie un séparateur. |
| 32 |
def nonEmpty: Boolean Vérifie si le conteneur contient des éléments (équivalent à hasNext). |
| 33 |
def padTo(len: Int, elem: A): Iterator[A] Retourne d'abord tous les éléments de l'itérateur, puis ajoute des copies de elem jusqu'à ce que la longueur atteigne len. |
| 34 |
def patch(from: Int, patchElems: Iterator[B], replaced: Int): Iterator[B] Retourne un nouvel itérateur, dans lequel les éléments remplacés à partir du from-ième élément sont remplacés par les éléments pointés par l'itérateur. |
| 35 |
def product: A Retourne le produit des éléments numériques auxquels l'itérateur fait référence. |
| 36 |
def sameElements(that: Iterator[_]): Boolean Détermine si l'itérateur et le paramètre d'itérateur spécifié renvoient les mêmes éléments dans l'ordre. |
| 37 |
def seq: Iterator[A] Retourne la vue de séquence de la collection. |
| 38 |
def size: Int Renvoie le nombre d'éléments dans l'itérateur. |
| 39 |
def slice(from: Int, until: Int): Iterator[A] Renvoie un nouvel itérateur pointant vers une tranche de la séquence pointée par l'itérateur, en commençant à l'élément d'indice from et en terminant à l'élément d'indice until. |
| 40 |
def sum: A Renvoie la somme des éléments numériques auxquels l'itérateur fait référence. |
| 41 |
def take(n: Int): Iterator[A] Renvoie un nouvel itérateur des n premiers éléments. |
| 42 |
def toArray: Array[A] Collecte tous les éléments pointés par l'itérateur dans un tableau et le renvoie. |
| 43 |
def toBuffer: Buffer[B] Copie tous les éléments pointés par l'itérateur dans le tampon Buffer. |
| 44 |
def toIterable: Iterable[A] Retourne un Iterable contenant tous les éléments de ce traversable ou itérateur. Cela ne se terminera pas pour les itérateurs infinis. |
| 45 |
def toIterator: Iterator[A] Collecte tous les éléments de l'itérateur dans un conteneur Iterator et le retourne. |
| 46 |
def toList: List[A] Collecte tous les éléments de l'itérateur dans une liste et la retourne. |
| 47 |
def toMap[T, U]: Map[T, U] Collecte toutes les paires clé-valeur de l'itérateur dans une Map et la retourne. |
| 48 |
def toSeq: Seq[A] Collecte tous les éléments de l'itérateur dans un conteneur Seq et le retourne. |
| 49 |
def toString(): String Convertit l'itérateur en chaîne de caractères. |
| 50 |
def zip[B](that: Iterator[B]): Iterator[(A, B) Renvoie un nouvel itérateur pointant vers une séquence de tuples à deux éléments, formés en appariant un à un les éléments de l'itérateur avec les éléments de l'itérateur spécifié. |
Pour plus de méthodes, veuillez consulterla documentation de l'API
Autres extensions
Collections Scala