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:
- Uso de bucles (enfoque ingenuo)
- En bucle
- Bucle para cada uno
- Mientras bucle
- Usando iterador
- Usando el iterador de lista
- Usando la expresión lambda
- 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
// 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
// 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
// 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
// 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
// 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
// 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
// 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
Publicación traducida automáticamente
Artículo escrito por mharshita31 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA