Scala Iterator (iterador)
Scala ColeccionesScala Iterator (iterador) no es una colección, es un método para acceder a colecciones.
Las dos operaciones básicas del iterador it son:nextyhasNext。
Llamar ait.next()devolverá el siguiente elemento del iterador y actualizará el estado del iterador.
Llamar ait.hasNext()se utiliza para detectar si todavía hay elementos en la colección.
La forma más sencilla de hacer que el iterador it devuelva todos los elementos uno por uno es usando un bucle while:
Ejemplo
def main(args: Array[String]) {
val it = Iterator("Baidu", "Google", "Ejemplo", "Taobao")
while (it.hasNext){
println(it.next())
}
}
}
Al ejecutar el código anterior, el resultado es:
$ scalac Test.scala $ scala Test Baidu Google Ejemplo Taobao
Encontrar el elemento máximo y mínimo
Puedes usar el métodoit.minyit.maxpara encontrar el elemento máximo y mínimo del iterador, como se muestra en el ejemplo:
Ejemplo
def main(args: Array[String]) {
val ita = Iterator(20,40,2,50,69, 90)
val itb = Iterator(20,40,2,50,69, 90)
println("El elemento máximo es:" + ita.max )
println("El elemento mínimo es:" + itb.min )
}
}
Al ejecutar el código anterior, el resultado es:
$ scalac Test.scala $ scala Test 最大元素是：90 最小元素是：2
Obtener la longitud del iterador
Puedes usar el métodoit.sizeoit.lengthpara ver el número de elementos del iterador, como se muestra en el ejemplo:
Ejemplo
def main(args: Array[String]) {
val ita = Iterator(20,40,2,50,69, 90)
val itb = Iterator(20,40,2,50,69, 90)
println("El valor de ita.size: " + ita.size )
println("El valor de itb.length: " + itb.length )
}
}
Al ejecutar el código anterior, el resultado es:
$ scalac Test.scala $ scala Test ita.size 的值: 6 itb.length 的值: 6
Métodos comunes de Scala Iterator
La siguiente tabla enumera los métodos comunes de Scala Iterator:
| N.º | Método y descripción |
|---|---|
| 1 |
def hasNext: Boolean Devuelve true si todavía hay elementos que pueden ser devueltos. |
| 2 |
def next(): A Devuelve el siguiente elemento del iterador y actualiza el estado del iterador. |
| 3 |
def ++(that: => Iterator[A]): Iterator[A] Combina dos iteradores |
| 4 |
def ++[B >: A](that :=> GenTraversableOnce[B]): Iterator[B] Combina dos iteradores |
| 5 |
def addString(b: StringBuilder): StringBuilder Agrega una cadena al StringBuilder b |
| 6 |
def addString(b: StringBuilder, sep: String): StringBuilder Agrega una cadena al StringBuilder b y especifica el separador |
| 7 |
def buffered: BufferedIterator[A] Convierte el iterador en BufferedIterator |
| 8 |
def contains(elem: Any): Boolean Detecta si el iterador contiene el elemento especificado |
| 9 |
def copyToArray(xs: Array[A], start: Int, len: Int): Unit Pasa los valores seleccionados del iterador a un array |
| 10 |
def count(p: (A) => Boolean): Int Devuelve el número total de elementos del iterador que cumplen la condición p. |
| 11 |
def drop(n: Int): Iterator[A] Devuelve una nueva colección descartando los primeros n elementos |
| 12 |
def dropWhile(p: (A) => Boolean): Iterator[A] Descarta elementos de izquierda a derecha hasta que la condición p no se cumpla |
| 13 |
def duplicate: (Iterator[A], Iterator[A]) Genera dos iteradores que pueden devolver todos los elementos del iterador por separado. |
| 14 |
def exists(p: (A) => Boolean): Boolean Devuelve un valor booleano que indica si existe algún elemento en el iterador que cumpla p. |
| 15 |
def filter(p: (A) => Boolean): Iterator[A] Devuelve un nuevo iterador que apunta a todos los elementos del iterador que cumplen la condición p. |
| 16 |
def filterNot(p: (A) => Boolean): Iterator[A] Devuelve un iterador que apunta a los elementos del iterador que no cumplen la condición p. |
| 17 |
def find(p: (A) => Boolean): Option[A] Devuelve el primer elemento que cumple p o None. Nota: si se encuentra un elemento que cumple la condición, el iterador se coloca después de ese elemento; si no se encuentra, se coloca al final. |
| 18 |
def flatMap[B](f: (A) => GenTraversableOnce[B]): Iterator[B] Aplica la función f a cada elemento de la secuencia del iterador y devuelve un iterador que apunta a la secuencia resultante. |
| 19 |
def forall(p: (A) => Boolean): Boolean Devuelve un valor booleano que indica si todos los elementos a los que apunta it cumplen p. |
| 20 |
def foreach(f: (A) => Unit): Unit Ejecuta el procedimiento especificado f en cada elemento devuelto por el iterador |
| 21 |
def hasDefiniteSize: Boolean Devuelve true si el número de elementos del iterador es finito (por defecto equivale a isEmpty) |
| 22 |
def indexOf(elem: B): Int Devuelve el primer elemento del iterador cuyo índice sea igual a x. Nota: el iterador saltará este elemento. |
| 23 |
def indexWhere(p: (A) => Boolean): Int Devuelve el elemento del iterador cuyo índice cumple la condición p. Nota: el iterador saltará este elemento. |
| 24 |
def isEmpty: Boolean Comprueba si it está vacío; devuelve true si está vacío, de lo contrario devuelve false (lo opuesto a hasNext). |
| 25 |
def isTraversableAgain: Boolean Tests whether this Iterator can be repeatedly traversed. |
| 26 |
def length: Int Devuelve el número de elementos del iterador. |
| 27 |
def map[B](f: (A) => B): Iterator[B] Genera un nuevo iterador con los resultados de pasar cada elemento de it por la función f. |
| 28 |
def max: A Devuelve el elemento más grande del iterador. |
| 29 |
def min: A Devuelve el elemento más pequeño del iterador. |
| 30 |
def mkString: String Convierte todos los elementos del iterador en una cadena. |
| 31 |
def mkString(sep: String): String Convierte todos los elementos del iterador en una cadena y especifica el separador. |
| 32 |
def nonEmpty: Boolean Comprueba si el contenedor contiene elementos (equivalente a hasNext). |
| 33 |
def padTo(len: Int, elem: A): Iterator[A] Primero devuelve todos los elementos del iterador, luego agrega copias de elem hasta que la longitud alcance len. |
| 34 |
def patch(from: Int, patchElems: Iterator[B], replaced: Int): Iterator[B] Devuelve un nuevo iterador donde los elementos replaced a partir del elemento from son reemplazados por los elementos a los que apunta el iterador. |
| 35 |
def product: A Devuelve el producto de los elementos numéricos a los que apunta el iterador. |
| 36 |
def sameElements(that: Iterator[_]): Boolean Determina si el iterador y el iterador especificado devuelven los mismos elementos en orden. |
| 37 |
def seq: Iterator[A] Devuelve una vista secuencial de la colección. |
| 38 |
def size: Int Devuelve el número de elementos del iterador. |
| 39 |
def slice(from: Int, until: Int): Iterator[A] Devuelve un nuevo iterador que apunta al segmento de la secuencia a la que apunta el iterador, desde el elemento from hasta el elemento until. |
| 40 |
def sum: A Devuelve la suma de los elementos numéricos a los que apunta el iterador. |
| 41 |
def take(n: Int): Iterator[A] Devuelve un nuevo iterador con los primeros n elementos. |
| 42 |
def toArray: Array[A] Reúne todos los elementos a los que apunta el iterador en un array y lo devuelve. |
| 43 |
def toBuffer: Buffer[B] Copia todos los elementos a los que apunta el iterador al búfer Buffer. |
| 44 |
def toIterable: Iterable[A] Returns an Iterable containing all elements of this traversable or iterator. This will not terminate for infinite iterators. |
| 45 |
def toIterator: Iterator[A] Reúne todos los elementos del iterador en un contenedor Iterator y lo devuelve. |
| 46 |
def toList: List[A] Reúne todos los elementos del iterador en una lista y la devuelve. |
| 47 |
def toMap[T, U]: Map[T, U] Reúne todos los pares clave-valor del iterador en un Map y lo devuelve. |
| 48 |
def toSeq: Seq[A] Reúne todos los elementos del iterador en un contenedor Seq y lo devuelve. |
| 49 |
def toString(): String Convierte el iterador en una cadena. |
| 50 |
def zip[B](that: Iterator[B]): Iterator[(A, B) Devuelve un nuevo iterador que apunta a una secuencia de pares formados por la correspondencia uno a uno entre los elementos del iterador y del iterador especificado that. |
Para obtener más métodos, consultala documentación de la API
Otras extensiones