Iteradores en Scala

Un iterador es una forma de acceder a los elementos de una colección uno por uno. Se parece a una colección en términos de sintaxis pero funciona de manera diferente en términos de funcionalidad. Un iterador definido para cualquier colección no carga toda la colección en la memoria, sino que carga los elementos uno tras otro. Por lo tanto, los iteradores son útiles cuando los datos son demasiado grandes para la memoria. Para acceder a los elementos podemos hacer uso de hasNext() para verificar si hay elementos disponibles y next() para imprimir el siguiente elemento.
Sintaxis:

val v = Iterator(5, 1, 2, 3, 6, 4)

//checking for availability of next element
while(v.hasNext)

//printing the element
println(v.next)

 
Definición de un iterador para una colección

Podemos definir un iterador para cualquier colección (arrays, listas, etc.) y podemos recorrer los elementos de esa colección en particular.
Ejemplo:

//Scala iterator program
//for defining iterator
  
//Creating object
object GFG
{
    // Main method
    def main(args:Array[String])
    {
        val v = Array(5,1,2,3,6,4)
        //val v = List(5,1,2,3,6,4)
      
        // defining an iterator
        // for a collection
        val i = v.iterator
      
        while (i.hasNext)
            print(i.next + " ")
    }
}

Producción:

5 1 2 3 6 4 

 
Formas de acceder a los elementos.

1. Uso del bucle while: la forma más sencilla de acceder a los elementos es usar el bucle while junto con los métodos hasNext y next .

// Scala iterator program // for accessing using while    // Creating object object GFG {     // Main method     def main(args:Array[String])     {         // defining iterator         val i = Iterator(5, 1, 2, 3, 6, 4)                /*         OR         val v = List(5, 1, 2, 3, 6, 4)         val i = v.iterator         */                // accessing elements using while loop         while (i.hasNext)             println(i.next)     } }

Producción:

5
1
2
3
6
4

2. Usando la acción foreach: Podemos hacer uso de foreach para imprimir elementos pasando la función println como parámetro. Tenga en cuenta que foreach es una función de orden superior que toma otra función como parámetro. En otras palabras, la función println se aplica a cada elemento.

// Scala iterator program // for accessing using foreach    // Creating object object GFG {     // Main method     def main(args:Array[String])     {         // defining iterator         val i = Iterator(5, 1, 2, 3, 6, 4)                /*         OR         val v = List(5, 1, 2, 3, 6, 4)         val i = v.iterator         */                // accessing elements using foreach         i foreach println         // same as i.foreach(println)     } }

Producción:

5
1
2
3
6
4

3. Usando for loop: Otra forma sencilla es usar for loop. Funciona de manera muy similar a acceder a elementos de cualquier colección usando for loop.

// Scala iterator program
// for accessing using for
  
// Creating object
object GFG
{
    // Main method
    def main(args:Array[String])
    {
        // defining iterator
        val i = Iterator(5, 1, 2, 3, 6, 4)
      
        /*
        OR
        val v = List(5, 1, 2, 3, 6, 4)
        val i = v.iterator
        */
      
        // accessing elements using for loop
        for(k <- i) println(k)
    }
}

Producción:

5
1
2
3
6
4

 
Encontrar elementos con valores mínimos y máximos

• Usando las funciones integradas min y max , los iteradores solo se pueden recorrer una vez. Por lo tanto, debemos redefinir el iterador después de encontrar el valor máximo.

// Scala iterator program for minimum // and maximum valued element // using built-in methods    // Creating object object GFG {     // Main method     def main(args:Array[String])     {         // defining iterator         val i1 = Iterator(5, 1, 2, 3, 6, 4)                // calling max function         println("Maximum: "+ i1.max)                // redefining iterator         val i2 = Iterator(5, 1, 2, 3, 6, 4)                // calling min function         println("Minimum: "+ i2.min)     } }

Producción:

Maximum: 6
Minimum: 1

El siguiente código imprime el elemento de valor mínimo:

// Scala iterator program
// for minimum valued element
// user defined method
  
// Creating object
object GFG
{
    // parameter is an Iterator of Int
    // returning Int value
    def small(ite : Iterator[Int]) : Int = 
    {
          
        // storing first value of collection
        var mn = ite.next
  
        for(i <- ite)
        if(i < mn) mn = i
          
        // returning     
        mn
          
    }
      
    // Main method
    def main(args:Array[String])
    {
        // defining iterator
        val i = Iterator(5, 1, 2, 3, 6, 4)
      
        //calling small function
        println("Minimum: "+ small(i))
    }
}

Producción:

Minimum: 1

El siguiente código imprime el elemento de valor máximo:

// Scala iterator program
// for maximum valued element
// user defined method
  
// Creating object
object GFG
{
    // parameter is an Iterator of Int
    // returning Int value
    def large(ite: Iterator[Int]): Int =
    {
          
        // storing first value of collection
        var mx = ite.next
  
        for(i <- ite)
        if(i > mx) mx = i
          
        // returning
        mx
    }
      
    // Main method
    def main(args:Array[String])
    {
        // defining iterator
        val i = Iterator(5, 1, 2, 3, 6, 4)
      
        // calling large function
        println("Maximum: "+ large(i))
    }
}

Producción:

Maximum: 6

NOTA: Ambas funciones, large() y small(), están escritas como dos códigos separados para reducir la carga del compilador en línea.