Iterar a través de List en Java

Las listas en java nos permiten mantener una colección ordenada de objetos. Los elementos duplicados, así como los elementos nulos, también se pueden almacenar en una Lista en Java. La interfaz List es parte del paquete java.util y hereda la interfaz Collection. Conserva el orden de inserción.

Hay varias formas de iterar sobre List en Java. Se discuten a continuación:

Métodos:

1. Uso de bucles (enfoque ingenuo)
   • En bucle
   • Bucle para cada uno
   • Mientras bucle
2. Usando iterador
3. Usando el iterador de lista
4. Usando la expresión lambda
5. Usando stream.forEach()

Método 1-A: Ciclo for simple

Se puede acceder a cada elemento por iteración usando un bucle for simple. Se puede acceder al índice utilizando el índice como una variable de bucle.

Sintaxis:

for (i = 0; i < list_name.size(); i++) 
{
  // code block to be executed
}

Ejemplo

// Java Program to iterate over List
// Using simple for loop
 
// Importing all classes of
// java.util package
import java.util.*;
 
// CLass
class GFG {
 
    // Main driver method
    public static void main(String args[])
    {
        // Creating a ArrayList
        List<String> myList = new ArrayList<String>();
 
        // Adding elements to the list
        // Custom inputs
        myList.add("A");
        myList.add("B");
        myList.add("C");
        myList.add("D");
 
        // For loop for iterating over the List
        for (int i = 0; i < myList.size(); i++) {
 
            // Print all elements of List
            System.out.println(myList.get(i));
        }
    }
}

A
B
C
D

Método 1-B: Bucle for mejorado

Se puede acceder a cada elemento por iteración utilizando un bucle for mejorado. Este bucle se introdujo en J2SE 5.0. Es un enfoque alternativo para atravesar el bucle for a. Hace que el código sea más legible.

Sintaxis:

for(data_type variable : List_name)
{  
 // Body of the loop. 
 // Each element can be accessed using variable.  
}

// Java Program to Iterate over a List
// using enhanced for loop (for-each)
 
// Importing all classes of
// java.util package
import java.util.*;
 
// Class
class GFG {
 
    // Main driver method
    public static void main(String args[])
    {
        // Creating an Arraylist
        List<String> myList = new ArrayList<String>();
 
        // Adding elements to the List
        // Custom inputs
        myList.add("A");
        myList.add("B");
        myList.add("C");
        myList.add("D");
 
        // Using enhanced for loop(for-each) for iteration
        for (String i : myList) {
 
            // Print all elements of ArrayList
            System.out.println(i);
        }
    }
}

A
B
C
D

Método 1-C: usar un bucle while

La iteración sobre una lista también se puede lograr usando un bucle while. El bloque de código dentro del ciclo se ejecuta hasta que la condición sea verdadera. Se puede utilizar una variable de bucle como índice para acceder a cada elemento.

Sintaxis:

while(variable<list_name.size())
{
   // Block of code to be executed 
}

// Java Program to iterate over a List
// using while loop
 
// Importing all classes of
// java.util package
import java.util.*;
 
// Class
class GFG {
 
    // Main driver method
    public static void main(String args[])
    {
        // Creating an ArrayList
        List<String> myList = new ArrayList<String>();
 
        // Adding elements to the List
        // Custom inputs
        myList.add("A");
        myList.add("B");
        myList.add("C");
        myList.add("D");
 
        // Initializing any variable to 0
        int i = 0;
 
        // If variable value is lesser than
        // value indicating size of List
        while (i < myList.size()) {
 
            // Print element of list
            System.out.println(myList.get(i));
 
            // Increase variable count by 1
            i++;
        }
    }
}

A
B
C
D

Método 2: Usar iterador

Un iterador es un objeto en Java que permite iterar sobre elementos de una colección. Se puede acceder a cada elemento de la lista mediante un iterador con un bucle while.

Sintaxis:

Iterator<data_type> variable = list_name.iterator();

Ejemplo

// Java Program to iterate over the list
// using iterator
 
// Importing all classes of
// java.util package
import java.util.*;
 
// Class
class GFG {
 
    // Main driver method
    public static void main(String args[])
    {
        // Creating an ArrayList
        List<String> myList = new ArrayList<String>();
 
        // Adding elements to the List
        // Custom inputs
        myList.add("A");
        myList.add("B");
        myList.add("C");
        myList.add("D");
 
        // Iterator
        Iterator<String> it = myList.iterator();
 
        // Condition check for elements in List
        // using hasNext() method returning true till
        // there i single element in a List
        while (it.hasNext()) {
 
            // Print all elements of List
            System.out.println(it.next());
        }
    }
}

A
B
C
D

Método 3: usar el iterador de lista

ListIterator es un iterador en Java que está disponible desde la versión 1.2. Nos permite iterar elementos uno por uno desde un objeto List implementado. Se usa para iterar sobre una lista usando el ciclo while.

Sintaxis

ListIterator<data_type> variable = list_name.listIterator();

// Java program to iterate over a list
// using ListIterator
import java.util.*;
 
// Class
class GFG {
 
    // Main driver method
    public static void main(String args[])
    {
        // Creating an ArrayList
        List<String> myList = new ArrayList<String>();
 
        // Adding elements to the List
        // Custom inputs
        myList.add("A");
        myList.add("B");
        myList.add("C");
        myList.add("D");
 
        // List iterator
        ListIterator<String> it = myList.listIterator();
 
        // Condition check whether there is element in List
        // using hasNext() which holds true till
        // there is single element in List
        while (it.hasNext()) {
 
            // Print all elements of List
            System.out.println(it.next());
        }
    }
}

A
B
C
D

Método 4: Usar Iterable.forEach()

Esta característica está disponible desde Java 8. También se puede usar para iterar sobre una Lista. La iteración se puede hacer usando una expresión lambda.

Sintaxis:

list_name.forEach(variable->{//block of code})

// Java Program to iterate over a List
// using forEach()
 
// Importing all classes of
// java.util method
import java.util.*;
 
// Class
class GFG {
 
    // Main driver method
    public static void main(String args[])
    {
        // Creating an ArrayList
        List<String> myList = new ArrayList<String>();
 
        // Adding elements to the List
        // Custom inputs
        myList.add("A");
        myList.add("B");
        myList.add("C");
        myList.add("D");
 
        // Lambda expression printing all elements in a List
        myList.forEach(
            (temp) -> { System.out.println(temp); });
    }
}

A
B
C
D

Método 5: Usar Stream.forEach()

El orden de procesamiento de stream().forEach() no está definido, mientras que en el caso de forEach(), está definido. Ambos se pueden usar para iterar sobre una Lista.

Sintaxis:

list_name.stream.forEach(variable->{//block of code})

// Java Program iterating over a List
// using stream.forEach() method
 
// Importing all classes of
// java.util method
import java.util.*;
 
// Class
class GFG {
 
    // Main driver method
    public static void main(String args[])
    {
        // Creating an ArrayList
        List<String> myList = new ArrayList<String>();
 
        // Adding elements to the List
        // Custom inputs
        myList.add("A");
        myList.add("B");
        myList.add("C");
        myList.add("D");
 
        // stream.forEach() method prints
        // all elements inside a List
        myList.stream().forEach(
            (temp) -> System.out.println(temp));
    }
}

A
B
C
D