ArrayList forma part de marc de recollida i està present al paquet java.util. Ens proporciona matrius dinàmiques en Java. Tanmateix, pot ser més lent que les matrius estàndard, però pot ser útil en programes on es necessita molta manipulació a la matriu. Aquesta classe es troba a java.util paquet.
Amb la introducció i les actualitzacions de les versions de Java, els mètodes més nous estan disponibles, com si veiéssim a Java8 que les expressions lambda perceptives i els conceptes de flux no estaven disponibles abans, ja que s'ha introduït a la versió 8 de Java.
Mètodes:
com convertir string en char
- S'utilitza for loops
- S'utilitza mentre
- S'utilitza per a cada bucle
- Utilitzant Iterator
- Ús d'expressions Lambda (només després de Java8)
- Utilitzant la interfície d'enumeració
Parlem d'aquests mètodes dels quals de seguida podem percebre que els tres mètodes inicials són simplement els enfocaments ingenus i els mètodes més endavant porten alguna optimització amb ells. Recordeu aquí, mentre que els elements que travessen són menors, generalment tendim a iterar mitjançant un enfocament ingenu només si la mida dels elements que cal inserir és gran, llavors fem servir enfocaments òptims. Anem a embolicar ràpidament cadascun dels enfocaments anteriors.
Mètode 1: S'utilitza for loop
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 nombres = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8); // Iterant utilitzant el bucle for for (int i = 0; i< numbers.size(); i++) // Printing and display the elements in ArrayList System.out.print(numbers.get(i) + ' '); } }> Sortida
1 2 3 4 5 6 7 8>
Mètode 2: S'utilitza 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 = nova ArrayList (); // Afegint elements a ArrayList // utilitzant el mètode add() al.add(3); al.add(1); al.add(7); al.add(20); al.add(5); // Pas 1: Configuració i inicialització d'una variable // segons la sintaxi del bucle while // Inicialment declarant i establint int val = 0; // Pas 2: Condició // Fins que la nostra variable de comptador sigui menor que la mida de // ArrayList while (al.size()> val) { // Imprimeix l'element que es manté per sobre // condició true System.out.println(al .get(val)); // Pas 3: Terminació de la condició augmentant // el nostre comptador a cada iteració val++ ; } } }>>>
Sortida 3 1 7 20 5>
Mètode 3: S'utilitza per a 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 nombres = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8); // Per a cada bucle per iterar ArrayList for (Integer i : nombres) // Imprimir els elements de ArrayList System.out.print(i + ' '); } }>>>
Sortida Mètode 4: Utilitzant Iterator
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 nombres = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8); // Iterant ArrayList utilitzant Iterator Iterator it = numbers.iterator(); // Es manté cert fins que hi ha un sol element // restant a la llista mentre (it.hasNext()) // Imprimeix els elements de ArrayList System.out.print(it.next() + ' '); } }>>>
Sortida Mètode 5: Ús d'expressions 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 nombres = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8); // Impressió de números amb expressions lambda // s'ha introduït més tard a java8 numbers.forEach(number->System.out.println(nombre)); } }>>>
Sortida Mètode 6: Utilitzant la interfície d'enumeració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 = nova ArrayList (); // Afegint elements a ArrayList al.add(34); al.add(12); al.add(34); al.add(23); al.add(54); // Obtenció d'un objecte d'enumeració Enumeració e = Col·leccions.enumeració(al); // Fins que hi ha elements mentre (e.hasMoreElements()) // Imprimeix elements amb el mètode nextElement() System.out.println(e.nextElement()); } }>>>
Sortida Ara és un additiu més a l'article, ja que hem acabat de discutir tots els mètodes que es poden utilitzar per iterar sobre elements. Fins ara només hem recorregut els elements d'entrada i no hem vist el recorregut, què passa si juguem amb elements, així que estem considerant Exemple
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 = nova ArrayList (); al.add(10); al.add(20); al.add(30); al.add(1); al.add(2); // Elimina elements menors de 10 utilitzant // Iterator.remove() Iterator itr = al.iterator(); mentre que (itr.hasNext()) { int x = (Enter)itr.next(); si (x< 10) itr.remove(); } System.out.println('Modified ArrayList : ' + al); } }>
Sortida Eliminació d'elements durant la travessa: No es recomana utilitzar ArrayList.remove() en iterar sobre elements. Això pot conduir a ConcurrentModificationException (Consulteu això per a un programa de mostra amb aquesta excepció). En iterar sobre elements, es recomana utilitzar-lo Iterator.remove() mètode.