ArrayList fait partie de cadre de collecte et est présent dans le package java.util. Il nous fournit des tableaux dynamiques en Java. Cependant, il peut être plus lent que les tableaux standard, mais peut être utile dans les programmes où de nombreuses manipulations dans le tableau sont nécessaires. Cette classe se retrouve dans java.util emballer.
Avec l'introduction et les mises à niveau dans les versions Java, des méthodes plus récentes sont disponibles comme si nous voyions dans Java8 que les expressions lambda perspicaces et les concepts de flux n'étaient pas disponibles avant cela, car ils ont été introduits dans la version Java8.
Méthodes :
k algorithme de clustering
- Utiliser des boucles for
- Utilisation pendant
- Utilisation de la boucle for-each
- Utiliser l'itérateur
- Utilisation d'expressions Lambda (après Java8 uniquement)
- Utilisation de l'interface d'énumération
Discutons de ces méthodes dont nous pouvons d'emblée percevoir que les trois méthodes initiales sont simplement des approches naïves et que, plus loin, les méthodes comportent une certaine optimisation. N'oubliez pas ici que même si les éléments traversants sont moindres, nous avons généralement tendance à itérer via une approche naïve uniquement, sinon si la taille des éléments à insérer est grande, nous utilisons des approches optimales. Examinons rapidement chacune des approches ci-dessus.
Méthode 1 : Utiliser la boucle 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 nombres = Arrays.asList(1, 2, 3, 4, 5, 6, 7, 8); // Itération en utilisant la boucle for for (int i = 0; i< numbers.size(); i++) // Printing and display the elements in ArrayList System.out.print(numbers.get(i) + ' '); } }> Sortir
1 2 3 4 5 6 7 8>
Méthode 2 : Utilisation de la boucle 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 = nouvelle liste de tableaux (); // Ajout d'éléments à ArrayList // en utilisant la méthode add() al.add(3); al.add(1); al.add(7); al.add(20); al.add(5); // Étape 1 : Définition et initialisation d'une variable // selon la syntaxe de la boucle while // Déclaration et définition initiales de int val = 0; // Étape 2 : Condition // Jusqu'à ce que notre variable de compteur soit inférieure à la taille de // ArrayList while (al.size()> val) { // Impression de l'élément qui est au-dessus // condition true System.out.println(al .get(val)); // Étape 3 : Terminer la condition en incrémentant // notre compteur à chaque itération val++ ; } } }> Sortir
3 1 7 20 5>
Méthode 3 : Utiliser pour chaque boucle
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); // For Each Boucle pour itérer ArrayList for (Integer i : number) // Impression des éléments d'ArrayList System.out.print(i + ' '); } }> Sortir
1 2 3 4 5 6 7 8>
Méthode 4 : Utiliser l'itérateur
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); // Itération de ArrayList à l'aide d'Iterator Iterator it = number.iterator(); // Reste vrai jusqu'à ce qu'il reste un seul élément // restant dans la liste while (it.hasNext()) // Affiche les éléments d'ArrayList System.out.print(it.next() + ' '); } }> Sortir
1 2 3 4 5 6 7 8>
Méthode 5 : Utiliser des 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); // Impression de nombres à l'aide d'expressions lambda // a été introduite plus tard dans java8 number.forEach(number->System.out.println(number)); } }> Sortir
1 2 3 4 5 6 7 8>
Méthode 6 : Utilisation de l'interface d'énumération
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 = nouvelle liste de tableaux (); // Ajout d'éléments à ArrayList al.add(34); al.add(12); al.add(34); al.add(23); al.add(54); // Obtention d'un objet d'énumération Enumération e = Collections.énumération(al); // Les éléments Till sont là while (e.hasMoreElements()) // Imprimer les éléments en utilisant la méthode nextElement() System.out.println(e.nextElement()); } }> Sortir
34 12 34 23 54>
Il s'agit désormais d'un complément supplémentaire à l'article, car nous en avons fini avec toutes les méthodes qui peuvent être utilisées pour parcourir les éléments. Jusqu'à présent, nous avons parcouru uniquement les éléments d'entrée et n'avons pas vu le parcours. Et si nous jouions avec les éléments, envisageons-nous aussi
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 = nouvelle liste de tableaux (); al.add(10); al.add(20); al.add(30); al.add(1); al.add(2); // Supprime les éléments inférieurs à 10 en utilisant // Iterator.remove() Iterator itr = al.iterator(); while (itr.hasNext()) { int x = (Integer)itr.next(); si (x< 10) itr.remove(); } System.out.println('Modified ArrayList : ' + al); } }> Sortir
Modified ArrayList : [10, 20, 30]>
Suppression d'éléments pendant la traversée : Il n'est pas recommandé d'utiliser ArrayList.remove() lors d'une itération sur des éléments. Cela peut conduire à ConcurrentModificationException (Faire référence à ce pour un exemple de programme avec cette exception). Lors d'une itération sur des éléments, il est recommandé d'utiliser Itérateur.remove() méthode.