Las listas en Java nos permiten mantener una colección ordenada de objetos. Los elementos duplicados y los elementos nulos también se pueden almacenar en una Lista en Java. La interfaz Lista es parte de java.util paquete y hereda la interfaz Colección. Conserva el orden de inserción.
Hay varias formas de iterar sobre List en Java. Se analizan a continuación:
Métodos:
- Usar bucles (enfoque ingenuo)
- Usando Iterador
- Usando iterador de lista
- Usando expresión lambda
- Usando flujo.forEach()
- Usando Spliterator (Java 8 y posterior)
Método 1-A: bucle for simple
Se puede acceder a cada elemento mediante iteración mediante un bucle for simple. Se puede acceder al índice utilizando el índice como variable de bucle.
Sintaxis:
for (i = 0; i>
A continuación se muestra un ejemplo de este método:
Java
// 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 ListmiLista = nueva ListaArray(); // Agregar elementos a la lista // Entradas personalizadas myList.add('A'); miLista.add('B'); miLista.add('C'); miLista.add('D'); // Bucle For para iterar sobre la Lista for (int i = 0; i< myList.size(); i++) { // Print all elements of List System.out.println(myList.get(i)); } } }> Producción
A B C D>
Complejidad del método anterior:
Complejidad del tiempo: O(n), donde 'n' es el tamaño de la lista.
Espacio Auxiliar: O (1), el espacio constante se utiliza para las variables de bucle (i en este caso).
Método 1-B: bucle for mejorado
Se puede acceder a cada elemento mediante iteración utilizando un bucle for mejorado. Este bucle se introdujo en J2SE 5.0. Es un enfoque alternativo para recorrer el bucle for. 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. }>A continuación se muestra el ejemplo de este método:
Java // 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 ListmiLista = nueva ListaArray(); // Agregar elementos a la Lista // Entradas personalizadas myList.add('A'); miLista.add('B'); miLista.add('C'); miLista.add('D'); // Uso de bucle for mejorado (for-each) para la iteración for (String i: myList) { // Imprime todos los elementos de ArrayList System.out.println(i); } } }> Producción
A B C D>
Complejidad del método anterior:
Complejidad del tiempo: O(n), donde 'n' es el tamaño de la lista.
Espacio Auxiliar: O (1), el espacio constante se utiliza para las variables de bucle (i en este caso).
Método 1-C: usar un bucle while
También se puede iterar sobre una lista utilizando un bucle while. El bloque de código dentro del bucle se ejecuta hasta que la condición sea verdadera. Se puede utilizar una variable de bucle como un índice para acceder a cada elemento.
Sintaxis:
while(variable>
A continuación se muestra el ejemplo de este método:
Java // 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 ListmiLista = nueva ListaArray(); // Agregar elementos a la Lista // Entradas personalizadas myList.add('A'); miLista.add('B'); miLista.add('C'); miLista.add('D'); // Inicializando cualquier variable a 0 int i = 0; // Si el valor de la variable es menor que // el valor indica el tamaño de la Lista mientras (i< myList.size()) { // Print element of list System.out.println(myList.get(i)); // Increase variable count by 1 i++; } } }> Producción
A B C D>
Complejidad del método anterior:
Complejidad del tiempo: O(n), donde 'n' es el tamaño de la lista.
Espacio Auxiliar : O(1), el espacio constante se utiliza para las variables de bucle (i en este caso).
Método 2: usar el 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 variable = list_name.iterator();>
A continuación se muestra el ejemplo de este método:
Java // 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 ListmiLista = nueva ListaArray(); // Agregar elementos a la Lista // Entradas personalizadas myList.add('A'); miLista.add('B'); miLista.add('C'); miLista.add('D'); // Iterador Iteradorit = miLista.iterador(); // Verificación de condiciones para elementos en la Lista // usando el método hasNext() que devuelve verdadero hasta // hay un solo elemento en una Lista while (it.hasNext()) { // Imprime todos los elementos de la Lista System.out.println(it .próximo()); } } }> Producción
A B C D>
Complejidad del método anterior:
Complejidad del tiempo: O(n), donde 'n' es el tamaño de la lista.
Espacio Auxiliar: O (1), el espacio constante se utiliza para las variables de bucle (i en este caso).
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 implementado Lista. Se utiliza para iterar sobre una lista usando el bucle while.
Sintaxis:
ListIterator variable = list_name.listIterator();>
A continuación se muestra el ejemplo de este método:
Java // 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 ListmiLista = nueva ListaArray(); // Agregar elementos a la Lista // Entradas personalizadas myList.add('A'); miLista.add('B'); miLista.add('C'); miLista.add('D'); // Listar iterador ListIteratorit = miLista.listIterator(); // Condición verifica si hay un elemento en la Lista // usando hasNext() que es válido hasta // hay un solo elemento en la Lista while (it.hasNext()) { // Imprime todos los elementos de la Lista System.out.println( it.siguiente()); } } }> Producción
A B C D>
Complejidad del método anterior:
Complejidad del tiempo: O(n), donde 'n' es el tamaño de la lista.
Espacio Auxiliar: O (1), el espacio constante se utiliza para las variables de bucle (i en este caso).cuando salio win 7
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 a expresión lambda.
Sintaxis:
list_name.forEach(variable->{//bloque de código})>A continuación se muestra el ejemplo de este método:
Java // 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 ListmiLista = nueva ListaArray(); // Agregar elementos a la Lista // Entradas personalizadas myList.add('A'); miLista.add('B'); miLista.add('C'); miLista.add('D'); // Expresión lambda que imprime todos los elementos de una Lista myList.forEach( (temp) -> { System.out.println(temp); }); } }> Producción
A B C D>
Complejidad del método anterior:
Complejidad del tiempo: O(n), donde 'n' es el tamaño de la lista.
Espacio Auxiliar: O (1), el espacio constante se utiliza para las variables de bucle (i en este caso).
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 utilizar para iterar sobre una Lista.
Sintaxis:
list_name.stream.forEach(variable->{//bloque de código})>A continuación se muestra el ejemplo de este método:
Java // 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 ListmiLista = nueva ListaArray(); // Agregar elementos a la Lista // Entradas personalizadas myList.add('A'); miLista.add('B'); miLista.add('C'); miLista.add('D'); // el método stream.forEach() imprime // todos los elementos dentro de una Lista myList.stream().forEach( (temp) -> System.out.println(temp)); } }> Producción
A B C D>
Complejidad del método anterior:
Complejidad del tiempo: O(n), donde 'n' es el tamaño de la lista.
Espacio Auxiliar: O (1), el espacio constante se utiliza para las variables de bucle (i en este caso).
Método 6: uso de Spliterator (Java 8 y posterior)
Java 8 introdujo el Separador interfaz, que significa iterador dividido. Proporciona una forma de iterar sobre elementos de una manera más compatible con el paralelo. Un Spliterator se puede obtener de varias fuentes, incluidas colecciones como listas. El método forEachRemaining de Spliterator se utiliza para recorrer todos los elementos restantes de forma secuencial.
Sintaxis:
Spliterator spliterator = myList.spliterator();>
A continuación se muestra el ejemplo de este método:
Java // Java Program iterating over a List // using Spliterator import java.util.List; import java.util.Spliterator; public class ListIteration { public static void main(String[] args) { // List of String ListmiLista = Lista.de('A', 'B', 'C','D'); // Usando Spliterator Spliteratordivisorio = miLista.spliterador(); spliterator.forEachRemaining(System.out::println); } }> Producción
A B C D>
Complejidad del método anterior:
Complejidad del tiempo: O(n), donde 'n' es el tamaño de la lista.
Espacio Auxiliar: O(log n) u O(1), (dependiendo de las características de la implementación de Spliterator)