Iterando sobre ArrayLists en Java

ArrayList es parte del marco de la colección y está presente en el paquete java.util. Nos proporciona arreglos dinámicos en Java. Sin embargo, puede ser más lento que las arrays estándar, pero puede ser útil en programas donde se necesita mucha manipulación en la array. Esta clase se encuentra en el paquete java.util .

Con la introducción y las actualizaciones en las versiones de Java, los métodos más nuevos están disponibles como si viéramos en Java8 expresiones lambda perceptivas y conceptos de flujos que no estaban disponibles antes de que se introdujeran en la versión de Java8.

Métodos:

1. Uso de bucles for
2. usando mientras
3. Usando el ciclo for-each
4. Usando iterador
5. Uso de expresiones Lambda (solo después de Java8)
6. Uso de la interfaz de enumeración

Analicemos estos métodos de los cuales podemos percibir de inmediato que los primeros tres métodos son simplemente los enfoques ingenuos y los métodos posteriores conllevan cierta optimización. Recuerde aquí, mientras que los elementos transversales son menores, generalmente tendemos a iterar a través de un enfoque ingenuo, solo si el tamaño de los elementos que se insertarán es grande, entonces usamos enfoques óptimos. Repasemos rápidamente cada uno de los enfoques anteriores.

Método 1: Uso del bucle for 

// Java  program to iterate over an ArrayList
// Using for loop
 
// Importing all utility classes
import java.util.*;
 
// Main class
class GFG {
   
    // Main driver method 
    public static void main(String[] args)
    {
        // Creating and initializing the ArrayList
        // Declaring object of integer type
        List<Integer> numbers = Arrays.asList(1, 2, 3,
                                       4, 5, 6, 7, 8);
 
        // Iterating using for loop
        for (int i = 0; i < numbers.size(); i++)
           
            // Printing and display the elements in ArrayList
            System.out.print(numbers.get(i) + " ");       
    }
}

1 2 3 4 5 6 7 8 

Método 2: usar el ciclo while 

// Java Program to Illustrate ArrayList
// Using While Loop
 
// Importing required classes
import java.util.ArrayList ;
 
// Main class
public class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Creating and initializing the ArrayList
        // Declaring object of integer type
        ArrayList<Integer> al = new ArrayList<Integer>();
 
        // Adding elements to ArrayList
        // using add() method
        al.add(3);
        al.add(1);
        al.add(7);
        al.add(20);
        al.add(5);
 
        // Step 1: Setting and initializing a variable
        // as per syntax of while loop
        // Initially declaring and setting
        int val = 0;
 
        // Step 2: Condition
        // Till our counter variable is lesser than size of
        // ArrayList
        while (al.size() > val) {
 
            // Printing the element which holds above
            // condition true
            System.out.println(al.get(val));
 
            // Step 3: Terminating condition by incrementing
            // our counter in each iteration
            val++ ;
        }
    }
}

3
1
7
20
5

Método 3: Usar para cada ciclo 

// Java Program to Iterate over Arraylist
// using for Each loop
 
// Importing all utility classes
import java.util.*;
 
// Main class
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
        // Declaring and initializing ArrayList
        List<Integer> numbers
            = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8);
 
        // For Each Loop for iterating ArrayList
        for (Integer i : numbers)
 
            // Printing the elements of ArrayList
            System.out.print(i + " ");
    }
}

1 2 3 4 5 6 7 8 

Método 4: usar el iterador 

// Java program to iterate over an ArrayList
// Using Iterator
 
// Importing all utility classes
import java.util.*;
 
// Main class
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
        // Declaring and initializing ArrayList
        List<Integer> numbers
            = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8);
 
        // Iterating ArrayList using Iterator
        Iterator it = numbers.iterator();
 
        // Holds true till there is single element
        // remaining in the list
        while (it.hasNext())
 
            // Print the elements of ArrayList
            System.out.print(it.next() + " ");
    }
}

1 2 3 4 5 6 7 8 

Método 5: Uso de expresiones lambda

// Java program to iterate over an arraylist
// using Iterator in Java8 with Lambda Expression
 
// Importing all utility classes
import java.util.*;
 
// Main class
class GFG {
   
    // Main driver method
    public static void main(String[] args)
    {
        // Declaring and initializing ArrayList
        // Custom input elements
        List<Integer> numbers = Arrays.asList(1, 2, 3,
                                       4, 5, 6, 7, 8);
 
        // Printing numbers using lambda expressions
        // been introduced later in java8
        numbers.forEach(number->System.out.println(number));
 
    }
}

1
2
3
4
5
6
7
8

Método 6: Uso de la interfaz de enumeración

// Java Program to Iterate over ArrayList elements
// Using Enumeration
 
// Importing required classes
import java.util.ArrayList;
import java.util.Collections;
import java.util.Enumeration;
 
// Main class
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Creating an ArrayList
        ArrayList<Integer> al = new ArrayList<Integer>();
 
        // Adding elements to ArrayList
        al.add(34);
        al.add(12);
        al.add(34);
        al.add(23);
        al.add(54);
 
        // Getting an enumeration object
        Enumeration<Integer> e
            = Collections.enumeration(al);
 
        // Till elements are there
        while (e.hasMoreElements())
 
            // Print elements using nextElement() method
            System.out.println(e.nextElement());
    }
}

34
12
34
23
54

Ahora es un agregado adicional al artículo, ya que hemos terminado de discutir todos los métodos que se pueden usar para iterar sobre los elementos. Hasta ahora, hemos atravesado elementos de entrada solamente y no hemos visto el recorrido. ¿Y si jugamos con elementos? ¿También estamos considerando 

Ejemplo 

// Java program to demonstrate Working of
// Iterator.remove() on Arraylist
 
// Importing utility classes
import java.util.List;
import java.util.ArrayList;
import java.util.Iterator;
 
// Main class
public class GFG
{
    // Main driver method
    public static void main(String[] args)
    {
        // Creating a List with referenceto ArrayList
        List<Integer> al = new ArrayList<Integer>();
        al.add(10);
        al.add(20);
        al.add(30);
        al.add(1);
        al.add(2);
 
        // Remove elements smaller than 10 using
        // Iterator.remove()
        Iterator itr = al.iterator();
        while (itr.hasNext())
        {
            int x = (Integer)itr.next();
            if (x < 10)
                itr.remove();
        }
 
        System.out.println("Modified ArrayList : "
                                           + al);
    }
}

Modified ArrayList : [10, 20, 30]

Eliminación de elementos durante el recorrido: no se recomienda usar ArrayList.remove() al iterar elementos. Esto puede conducir a ConcurrentModificationException (consulte esto para ver un programa de muestra con esta excepción). Al iterar sobre elementos, se recomienda utilizar el método Iterator.remove() . 

Este artículo es una contribución de Nikita Tiwari . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a review-team@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.
Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.