English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية
Scala Iterator (iterador) não é uma coleção, é um método para acessar a coleção.
As duas operações básicas do iterador it são next e hasNext.
chama it.next() retorna o próximo elemento do iterador e atualiza o estado do iterador.
chama it.hasNext() usado para verificar se há mais elementos na coleção.
A maneira mais simples de fazer o iterador it retornar todos os elementos individualmente é usar um loop while:
object Test {
def main(args: Array[String]) {
val it = Iterator("Baidu", "Google", "w3codebox", "Taobao")
while(it.hasNext){
println(it.next())
}
}
}executar o código acima, o resultado de saída será:
$ scalac Test.scala $ scala Test Baidu Google w3codebox Taobao
você pode usar it.min e it.max Método para encontrar o maior e o menor elemento no iterador, exemplo a seguir:
object Test {
def main(args: Array[String]) {
val ita = Iterator(20,40,2,50,69, 90)
val itb = Iterator(20,40,2,50,69, 90)
println("o maior elemento é: ") + ita.max)
println("o menor elemento é: ") + itb.min)
}
}executar o código acima, o resultado de saída será:
$ scalac Test.scala $ scala Test o maior elemento é:90 o menor elemento é:2
você pode usar it.size ou it.length métodos para verificar o número de elementos no iterador. O exemplo é o seguinte:
object Test {
def main(args: Array[String]) {
val ita = Iterator(20,40,2,50,69, 90)
val itb = Iterator(20,40,2,50,69, 90)
println("o valor de ita.size: ") + ita.size)
println("o valor de itb.length: ") + itb.length)
}
}executar o código acima, o resultado de saída será:
$ scalac Test.scala $ scala Test o valor de ita.size: 6 o valor de itb.length: 6
a tabela a seguir lista os métodos comuns do Scala Iterator:
| número sequencial | método e descrição |
|---|---|
| 1 | def hasNext: Boolean se houver mais elementos a serem retornados, retornar true. |
| 2 | def next(): A retornar o próximo elemento do iterador e atualizar o estado do iterador |
| 3 | def ++(that: => Iterator[A]): Iterator[A] mesclar dois iteradores |
| 4 | def ++[B >: A](that :=> GenTraversableOnce[B]): Iterator[B] mesclar dois iteradores |
| 5 | def addString(b: StringBuilder): StringBuilder adicionar uma string ao StringBuilder b |
| 6 | def addString(b: StringBuilder, sep: String): StringBuilder adicionar uma string ao StringBuilder b, e especificar o delimitador |
| 7 | def buffered: BufferedIterator[A] todos os iteradores são convertidos em BufferedIterator |
| 8 | def contains(elem: Any): Boolean detetar se o iterador contém o elemento especificado |
| 9 | def copyToArray(xs: Array[A], start: Int, len: Int): Unit Passa os valores selecionados do iterador para um array |
| 10 | def count(p: (A) => Boolean): Int Retorna o número total de elementos do iterador que satisfazem a condição p |
| 11 | def drop(n: Int): Iterator[A] Retorna um novo conjunto com os n primeiros elementos descartados |
| 12 | def dropWhile(p: (A) => Boolean): Iterator[A] Descarta elementos da esquerda para a direita até que a condição p não seja mais verdadeira |
| 13 | def duplicate: (Iterator[A], Iterator[A]) Gera dois iteradores que podem retornar todos os elementos do iterador |
| 14 | def exists(p: (A) => Boolean): Boolean Retorna um valor booleano que indica se existe algum elemento no iterador que satisfaça a condição p |
| 15 | def filter(p: (A) => Boolean): Iterator[A] Retorna um novo iterador que aponta para todos os elementos do iterador que satisfazem a condição p |
| 16 | def filterNot(p: (A) => Boolean): Iterator[A] Retorna um iterador que aponta para os elementos do iterador que não satisfazem a condição p |
| 17 | def find(p: (A) => Boolean): Option[A] Retorna o primeiro elemento que satisfaz a condição p ou None. Atenção: se encontrar um elemento que satisfaça a condição, o iterador será colocado após esse elemento; se não encontrar, será colocado no ponto final. |
| 18 | def flatMap[B](f: (A) => GenTraversableOnce[B]): Iterator[B] Aplica a função f a cada elemento da sequência do iterador e retorna um iterador que aponta para a sequência de resultados |
| 19 | def forall(p: (A) => Boolean): Boolean Retorna um valor booleano que indica se todos os elementos a que it se refere satisfazem a condição p |
| 20 | def foreach(f: (A) => Unit): Unit Executa o programa específico f em cada elemento retornado pelo iterador |
| 21 | def hasDefiniteSize: Boolean Retorna true se o número de elementos do iterador for finito (padrão é equivalente a isEmpty) |
| 22 | def indexOf(elem: B): Int Retorna o primeiro elemento do iterador cujo índice é igual a x. Atenção: o iterador passa por esse elemento. |
| 23 | def indexWhere(p: (A) => Boolean): Int Retorna os elementos do iterador cujo índice atende a condição p. Atenção: o iterador passa por esse elemento. |
| 24 | def estáVazio: Boolean Verifica se it está vazio, retorna true se estiver vazio, caso contrário retorna false (ao contrário de hasNext). |
| 25 | def éNovamenteTraversable: Boolean Testa se este Iterator pode ser percorrido repetidamente. |
| 26 | def comprimento: Int Retorna o número de elementos do iterador. |
| 27 | def mapear[B](f: (A) => B): Iterator[B] Insere cada elemento de it no função f e gera um novo iterador com os resultados. |
| 28 | def max: A Retorna o elemento maior dos elementos iterados pelo iterador. |
| 29 | def min: A Retorna o elemento mais pequeno dos elementos iterados pelo iterador. |
| 30 | def mkString: String Converte todos os elementos do iterador em uma string. |
| 31 | def mkString(sep: String): String Converte todos os elementos do iterador em uma string, especificando o separador. |
| 32 | def nãoVazio: Boolean Verifica se o contêiner contém o elemento (equivalente a hasNext). |
| 33 | def preencherAté(len: Int, elem: A): Iterator[A] Primeiro retorna todos os elementos do iterador, adiciona cópias de elem até que o comprimento atinja len. |
| 34 | def reparar(from: Int, repararElems: Iterator[B], substituídos: Int): Iterator[B] Retorna um novo iterador, onde os replaced elementos começando pelo elemento de índice from são substituídos pelos elementos apontados pelo iterador. |
| 35 | def produto: A Retorna o produto dos elementos numéricos apontados pelo iterador |
| 36 | def mesmosElementos(que: Iterator[_]): Boolean Verifica se o iterador e o iterador especificado retornam elementos em ordem subsequente |
| 37 | def seq: Iterator[A] Retorna uma visão sequencial da coleção |
| 38 | def tamanho: Int Retorna o número de elementos do iterador |
| 39 | def fatiar(from: Int, until: Int): Iterator[A] Retorna um novo iterador, apontando para o fragmento da sequência apontada pelo iterador, começando pelo elemento de índice from e terminando pelo elemento de índice until. |
| 40 | def somar: A Retorna a soma dos elementos numéricos apontados pelo iterador |
| 41 | def take(n: Int): Iterador[A] Retorna um novo iterador contendo os primeiros n elementos. |
| 42 | def toArray: Array[A] Aloca todos os elementos apontados pelo iterador em um array e retorna. |
| 43 | def toBuffer: Buffer[B] Copia todos os elementos apontados pelo iterador para o buffer Buffer. |
| 44 | def toIterable: Iterable[A] Retorna um Iterable contendo todos os elementos deste traversable ou iterador. Isso não terminará para iteradores infinitos. |
| 45 | def toIterator: Iterador[A] Aloca todos os elementos do iterador em um contêiner Iterador e retorna. |
| 46 | def toList: Lista[A] Aloca todos os elementos do iterador em uma lista e retorna |
| 47 | def toMap[T, U]: Map[T, U] Aloca todos os pares de chave-valor do iterador em um Map e retorna. |
| 48 | def toSeq: Seq[A] Aloca todos os elementos do iterador em um contêiner Seq e retorna. |
| 49 | def toString(): String Converte o iterador em uma string |
| 50 | def zip[B](that: Iterador[B]): Iterador[(A, B)] Retorna um novo iterador que aponta para uma sequência de pares binários formados por elementos correspondentes de dois iteradores especificados |
Mais métodos podem ser consultados Documentação da API