ArrayList es parte de marco de colección y está presente en el paquete java.util. Nos proporciona matrices dinámicas en Java. Sin embargo, puede ser más lento que los arreglos estándar, pero puede ser útil en programas donde se necesita mucha manipulación en el arreglo. Esta clase se encuentra en java.util paquete.
Con la introducción y las actualizaciones en las versiones de Java, están disponibles métodos más nuevos, como si viéramos en Java8, las expresiones lambda perceptivas y los conceptos de flujos no estaban disponibles antes, como se introdujo en la versión 8 de Java.
Métodos:
stlc
- Usando bucles for
- Usando mientras
- Usando bucle para cada
- Usando iterador
- Usar expresiones Lambda (solo después de Java8)
- Usando la interfaz de enumeración
Analicemos estos métodos, de los cuales inmediatamente podemos percibir que los tres métodos iniciales son simplemente enfoques ingenuos y, en adelante, los métodos conllevan cierta optimización. Recuerde aquí, si bien los elementos transversales son menores, generalmente tendemos a iterar mediante un enfoque ingenuo; de lo contrario, si el tamaño de los elementos a insertar es grande, entonces utilizamos enfoques óptimos. Repasemos rápidamente cada uno de los enfoques anteriores.
Método 1: Usando bucle for
Java
// 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 números = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8); // Iterando usando el bucle for (int i = 0; i< numbers.size(); i++) // Printing and display the elements in ArrayList System.out.print(numbers.get(i) + ' '); } }> Producción
1 2 3 4 5 6 7 8>
Método 2: Usando el bucle while
Java // 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 al = nueva lista de matrices (); // Agregar elementos a ArrayList // usando el método add() al.add(3); al.add(1); al.add(7); al.add(20); al.add(5); // Paso 1: Configurar e inicializar una variable // según la sintaxis del bucle while // Declarar y configurar inicialmente int val = 0; // Paso 2: Condición // Hasta que nuestra variable de contador sea menor que el tamaño de // ArrayList while (al.size()> val) { // Imprimiendo el elemento que contiene arriba // condición verdadera System.out.println(al .obtener(val)); // Paso 3: Terminar la condición incrementando // nuestro contador en cada iteración val++; } } }> Producción
3 1 7 20 5>
Método 3: Usando para cada bucle
Java // 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 números = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8); // For Each Loop para iterar ArrayList for (Integer i: números) // Imprimir los elementos de ArrayList System.out.print(i + ' '); } }> Producción
1 2 3 4 5 6 7 8>
Método 4: Usando iterador
Java
// 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 números = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8); // Iterando ArrayList usando Iterator Iterator it = números.iterator(); // Se mantiene verdadero hasta que queda un solo elemento // que permanece en la lista while (it.hasNext()) // Imprime los elementos de ArrayList System.out.print(it.next() + ' '); } }> Producción
1 2 3 4 5 6 7 8>
Método 5: Usando expresiones Lambda
Java // 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 números = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8); // Imprimir números usando expresiones lambda // se introdujo más adelante en java8 number.forEach(number->System.out.println(number)); } }> Producción
1 2 3 4 5 6 7 8>
Método 6: Usando la interfaz de enumeración
Java // 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 al = nueva lista de matrices (); // Agregar elementos a ArrayList al.add(34); al.add(12); al.add(34); al.add(23); al.add(54); // Obteniendo un objeto de enumeración Enumeración e = Colecciones.enumeración(al); // Hasta que los elementos estén ahí while (e.hasMoreElements()) // Imprimir elementos usando el método nextElement() System.out.println(e.nextElement()); } }> Producción
34 12 34 23 54>
Ahora es una adición adicional al artículo, ya que hemos terminado de analizar todos los métodos que se pueden usar para iterar sobre elementos. Hasta ahora hemos atravesado solo elementos de entrada y no hemos visto el recorrido. ¿Qué pasa si jugamos con elementos? Entonces, ¿estamos considerando?
Ejemplo
Java // 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 al = nueva lista de matrices (); al.add(10); al.add(20); al.add(30); al.add(1); al.add(2); // Elimina elementos menores de 10 usando // Iterator.remove() Iterator itr = al.iterator(); mientras (itr.hasNext()) { int x = (Entero)itr.next(); si (x< 10) itr.remove(); } System.out.println('Modified ArrayList : ' + al); } }> Producción
Modified ArrayList : [10, 20, 30]>
Eliminación de elementos durante el recorrido: No se recomienda utilizar ArrayList.remove() al iterar sobre elementos. Esto puede llevar a ConcurrentModificationException (Referirse a este para un programa de muestra con esta excepción). Al iterar sobre elementos, se recomienda utilizar Iterador.remove() método.