Menu

Java ArrayList - Comment déclarer, initialiser et imprimer une ArrayList

  • Principal
  • Autre
  • Java ArrayList - Comment déclarer, initialiser et imprimer une ArrayList

java arraylist how declare

Essayez Notre Instrument Pour Éliminer Les Problèmes

Ce didacticiel explique comment déclarer, initialiser et imprimer Java ArrayList avec des exemples de code. Vous apprendrez également sur 2D Arraylist et l'implémentation de ArrayList en Java:

Java Collections Framework et l'interface List ont été expliqués en détail dans nos précédents tutoriels. ArrayList est une structure de données qui fait partie de la structure de collections et peut être considérée comme similaire aux tableaux et aux vecteurs.

ArrayList peut être perçu comme un tableau dynamique qui vous permet d'ajouter ou de supprimer des éléments à tout moment ou simplement dit, dynamiquement.

=> Jetez un œil au guide du débutant Java ici.

ArrayList en Java

En d'autres termes, sa taille peut augmenter ou diminuer dynamiquement contrairement aux tableaux dont la taille reste statique une fois déclarée.

Ce que vous apprendrez:

Classe ArrayList en Java

La structure de données ArrayList en Java est représentée par la classe ArrayList qui fait partie du ' java.util ' paquet.

La hiérarchie de la classe ArrayList est illustrée ci-dessous.

Hiérarchie de la classe ArrayList

Comme vous pouvez le voir, la classe ArrayList implémente l'interface List qui à son tour s'étend à partir de l'interface Collection.

La définition générale de la classe ArrayList est donnée ci-dessous:

public class ArrayList extends AbstractList implements List,RandomAccess, Cloneable, Serializable

Voici quelques-unes des caractéristiques distinctives de ArrayList:

  • La classe ArrayList de Java stocke les éléments en conservant l'ordre d'insertion.
  • ArrayList autorise les éléments dupliqués qui y sont stockés.
  • ArrayList n'est pas synchronisé, le point majeur qui différencie la classe ArrayList de la classe Vector en Java.
  • ArrayList en Java est plus identique aux vecteurs en C ++.
  • Le ArrayList en Java utilise également des index tels que des tableaux et prend en charge l'accès aléatoire.
  • Les opérations qui manipulent les éléments dans ArrayList sont lentes car de nombreux changements d'éléments doivent être effectués si un élément doit être supprimé de ArrayList.
  • La classe ArrayList ne peut pas contenir de types primitifs mais uniquement des objets. Dans ce cas, nous l’appelons généralement «ArrayList of objects». Donc, si vous souhaitez stocker des éléments de type entier, vous devez utiliser l'objet Integer de la classe wrapper et non le type primitif int.

Créer et déclarer ArrayList

Pour utiliser la classe ArrayList dans votre programme, vous devez l’inclure d’abord dans votre programme en utilisant la directive ‘import’ comme indiqué ci-dessous:

import java.util.ArrayList;

OU

import java.util.*; //this will include all classes from java.util package

Une fois que vous avez importé la classe ArrayList dans votre programme, vous pouvez créer un objet ArrayList.

La syntaxe générale de création ArrayList est:

ArrayList arrayList = new ArrayList ();

Outre l'instruction ci-dessus qui utilise le constructeur par défaut, la classe ArrayList fournit également d'autres constructeurs surchargés que vous pouvez utiliser pour créer le ArrayList.

Méthodes du constructeur

La classe ArrayList en Java fournit les méthodes de constructeur suivantes pour créer ArrayList.

Méthode n ° 1: ArrayList ()

Cette méthode utilise le constructeur par défaut de la classe ArrayList et est utilisée pour créer un ArrayList vide.

La syntaxe générale de cette méthode est:

ArrayList list_name = new ArrayList();

Par exemple, vous pouvez créer une ArrayList générique de type String à l'aide de l'instruction suivante.

ArrayList arraylist = new ArrayList();

Cela créera une ArrayList vide nommée «arraylist» de type String.

Méthode n ° 2: ArrayList (capacité int)

Ce constructeur surchargé peut être utilisé pour créer une ArrayList avec la taille ou la capacité spécifiée fournie en tant qu'argument du constructeur.

La syntaxe générale de cette méthode est:

ArrayList list_name = new ArrayList(int capacity);

Exemple:

ArrayList arraylist = new ArrayList(10);

L'instruction ci-dessus crée une ArrayList vide nommée «arraylist» de type Integer avec une capacité de 10.

Méthode n ° 3: ArrayList (Collection c)

Le troisième constructeur surchargé de la classe ArrayList prend une collection déjà existante comme argument et crée un ArrayList avec les éléments de la collection spécifiée c comme éléments initiaux.

La syntaxe générale de l'initialisation ArrayList à l'aide de ce constructeur est:

ArrayList list_name = new ArrayList (Collection c)

Par exemple, si intList est une collection existante avec des éléments {10,20,30,40,50}, alors l'instruction suivante créera une liste «arraylist» avec le contenu de intList comme éléments initiaux.

ArrayList ArrayList = new ArrayList(intList);

La classe ArrayList prend également en charge diverses méthodes qui peuvent être utilisées pour manipuler le contenu de la liste. Nous discuterons de ces méthodes en détail dans notre prochain tutoriel «Méthodes ArrayList en Java».

Initialiser ArrayList en Java

Une fois la ArrayList créée, il existe plusieurs façons d'initialiser la ArrayList avec des valeurs. Dans cette section, nous discuterons de ces manières.

# 1) Utilisation de Arrays.asList

Ici, vous pouvez transmettre un Array converti en List à l'aide de la méthode asList de la classe Arrays pour initialiser ArrayList.

Syntaxe générale:

ArrayList arrayListName = new ArrayList( Arrays.asList (Object o1, Object o2, …, Object on));

Exemple:

import java.util.*; public class Main { public static void main(String args()) { //create and initialize ArrayList object myList with Arrays.asList method ArrayList myList = new ArrayList( Arrays.asList('One', 'Two', 'Three')); //print the ArrayList System.out.println('List contents:'+myList); } }

Production:

Initialiser ArrayList en Java

# 2) Utilisation de la méthode de classe interne anonyme

Ici, nous utilisons la classe interne anonyme pour initialiser ArrayList aux valeurs.

La syntaxe générale pour l'utilisation d'une classe interne anonyme pour l'initialisation de ArrayList est la suivante:

ArrayListarraylistName = new ArrayList(){{ add(Object o1); add (Object o2);… add (Object on);}};

Exemple:

import java.util.*; public class Main { public static void main(String args()) { //create and initialize ArrayList with anonymous inner class calls ArrayList colors = new ArrayList(){{ add('Red'); add('Blue'); add('Purple'); }}; //print the ArrayList System.out.println('Content of ArrayList:'+colors); } }

Production:

Utilisation de la méthode de classe interne anonyme

# 3) Utilisation de la méthode add

C'est la méthode courante pour ajouter des éléments à n'importe quelle collection.

La syntaxe générale pour utiliser la méthode add pour ajouter des éléments à ArrayList est:

ArrayListArraylistName = new ArrayList(); ArraylistName.add(value1); ArraylistName.add(value2); ArraylistName.add(value3);

Exemple de programmation:

import java.util.*; public class Main { public static void main(String args()) { //create ArrayList ArrayList colors = new ArrayList(); //add elements to the ArrayList using add method colors.add('Red'); colors.add('Green'); colors.add('Blue'); colors.add('Orange'); //print the ArrayList System.out.println('Content of ArrayList:'+colors); }

Production:

Utilisation de la méthode add

# 4) Utilisation de la méthode Collection.nCopies

Cette méthode est utilisée pour initialiser ArrayList avec les mêmes valeurs. Nous fournissons le nombre d'éléments à initialiser et la valeur initiale de la méthode.

La syntaxe générale de l'initialisation est:

ArrayList arrayListName = new ArrayList(Collections.nCopies(count, element));

L'exemple ci-dessous illustre l'initialisation de Array à l'aide de la méthode Collections.nCopies.

import java.util.*; public class Main { public static void main(String args()) { //create ArrayList with 10 elements //initialized to value 10 using Collections.nCopies ArrayList intList = new ArrayList(Collections.nCopies(10,10)); //print the ArrayList System.out.println('Content of ArrayList:'+intList); } }

Production:

Utilisation de la méthode Collection.nCopies

Itération dans ArrayList

Nous avons les moyens suivants pour traverser ou faire une boucle dans ArrayList:

  1. Utilisation de la boucle for
  2. Par boucle for-each (boucle for améliorée).
  3. Utilisation de l'interface Iterator.
  4. Par l'interface ListIterator.
  5. Par la méthode forEachRemaining ().

En fait, ces méthodes sont utilisées pour parcourir les collections en général. Nous verrons des exemples de chacune des méthodes par rapport à ArrayList dans ce didacticiel.

# 1) Utilisation de la boucle for

Une boucle for basée sur un index peut être utilisée pour parcourir ArrayList et imprimer ses éléments.

Voici un exemple pour parcourir et imprimer la ArrayList à l'aide de la boucle for.

import java.util.*; public class Main { public static void main(String() args) { //create a list List intList = new ArrayList(); intList.add(10); intList.add(20); intList.add(30); intList.add(40); intList.add(50); //create & initialize a new ArrayList with previous list ArrayList arraylist = new ArrayList(intList); System.out.println('Contents of ArrayList using for-loop:'); //use for loop to traverse through its elements and print it for(int i=0;i

Production:

Par la méthode forEachRemaining ()

C'est le moyen le plus simple et le plus simple de parcourir et d'imprimer les éléments de ArrayList et fonctionne de la même manière dans le cas d'autres collections.

# 2) Par boucle for-each (boucle for améliorée)

Vous pouvez également parcourir ArrayList à l'aide d'une boucle for-each ou de la boucle for améliorée. Avant Java 8, il n'incluait pas d'expressions lambda. Mais à partir de Java 8, vous pouvez également inclure des expressions Lambda dans la boucle for-each.

Le programme ci-dessous montre le parcours et l'impression de ArrayList en utilisant pour chaque boucle et expression lambda.

import java.util.*; public class Main { public static void main(String() args) { //create a list List intList = new ArrayList(); intList.add(10); intList.add(20); intList.add(30); intList.add(40); intList.add(50); //create & initialize a new ArrayList with previous list ArrayList arraylist = new ArrayList(intList); System.out.println('Contents of ArrayList using for-each loop:'); //use for-each loop to traverse through its elements and print it intList.forEach(val ->{ System.out.print(val + ' '); }); } }

Production:

Par pour chaque boucle

# 3) Utilisation de l'interface Iterator

Nous avons vu l'interface Iterator en détail dans nos rubriques précédentes. L'interface Iterator peut être utilisée pour parcourir l'ArrayList et afficher ses valeurs.

Le programme suivant le montre.

import java.util.*; public class Main { public static void main(String() args) { //create a list List intList = new ArrayList(); intList.add(5); intList.add(10); intList.add(15); intList.add(20); intList.add(25); //create & initialize a new ArrayList with previous list ArrayList arraylist = new ArrayList(intList); System.out.println('Contents of ArrayList using Iterator interface:'); //Traverse through the ArrayList using iterator Iterator iter=arraylist.iterator(); while(iter.hasNext()){ System.out.print(iter.next() + ' '); } } }

Production:

Utilisation de l

# 4) Par l'interface ListIterator

Vous pouvez également parcourir ArrayList à l'aide de ListIterator. ListIterator peut être utilisé pour parcourir ArrayList en avant comme en arrière.

Implémentons un programme Java illustrant un exemple d’utilisation de ListIterator.

import java.util.*; class Main{ public static void main(String args()){ //create a list and initiliaze it List colors_list=new ArrayList();//Creating arraylist colors_list.add('Red'); colors_list.add('Green'); colors_list.add('Blue'); colors_list.add('Cyan'); colors_list.add('Magenta'); colors_list.add('Yellow'); System.out.println('The contents of the list using ListIterator:'); //Traverse the list using ListIterator ListIterator color_iter=colors_list.listIterator(colors_list.size()); while(color_iter.hasPrevious()) { String str=color_iter.previous(); System.out.print(str + ' '); } } }

Production:

Par l

Comme vous pouvez le voir à partir de la sortie, dans le programme ci-dessus, ArrayList est parcouru vers l'arrière en utilisant les méthodes hasPrevious () et previous () de ListIterator.

# 5) Par la méthode forEachRemaining ()

C'est l'une des méthodes pour parcourir ArrayList et est disponible depuis Java 8.

Le programme suivant illustre la méthode forEachRemaining () pour parcourir ArrayList.

import java.util.*; class Main{ public static void main(String args()){ //create a list and initiliaze it List colors_list=new ArrayList(); colors_list.add('Red'); colors_list.add('Green'); colors_list.add('Blue'); colors_list.add('Cyan'); colors_list.add('Magenta'); colors_list.add('Yellow'); System.out.println('The contents of the list using forEachRemaining() method:'); //Traverse the list using forEachRemaining () method Iterator itr=colors_list.iterator(); itr.forEachRemaining(val-> //lambda expression { System.out.print(val + ' '); }); } }

Production:

Par la méthode forEachRemaining ()

quel est le système d'exploitation de l'ordinateur

Nous utilisons la méthode forEachRemaining () avec un Iterator. Il est similaire à chacun et nous utilisons l'expression lambda dans cette méthode.

Exemple Java ArrayList

Dans cette section, nous verrons l'implémentation d'ArrayList en Java. À titre d'exemple, nous allons implémenter un exemple complet de création, d'initialisation et d'utilisation de Java ArrayList pour effectuer diverses manipulations.

import java.util.ArrayList; class Main { public static void main(String() args) { //Creating a generic ArrayList ArrayList newList = new ArrayList(); //Size of arrayList System.out.println('Original size of ArrayList at creation: ' + newList.size()); //add elements to it newList.add('IND'); newList.add('USA'); newList.add('AUS'); newList.add('UK'); //print the size after adding elements System.out.println('ArrayList size after adding elements: ' + newList.size()); //Print ArrayList contents System.out.println('Contents of the ArrayList: ' + newList); //Remove an element from the list newList.remove('USA'); System.out.println('ArrayList contents after removing element(USA): ' + newList); //Remove another element by index newList.remove(2); System.out.println('ArrayList contents after removing element at index 2: ' + newList); //print new size System.out.println('Size of arrayList: ' + newList.size()); //print list contents System.out.println('Final ArrayList Contents: ' + newList); } }

Production:

Exemple ArrayList Java

ArrayList bidimensionnel en Java

Nous savons qu'un ArrayList n'a pas de dimensions comme les tableaux. Mais nous pouvons avoir des ArrayLists imbriquées qui sont également appelées «2D ArrayLists» ou «ArrayList of ArrayLists».

L'idée simple derrière ces ArrayList imbriquées est que, étant donné un ArrayList, chaque élément de ce ArrayList est un autre ArrayList.

Comprenons cela en utilisant le programme suivant.

import java.util.*; public class Main { public static void main(String() args) { int num = 3; // declare an arrayList of ArrayLists or 2D ArrayList ArrayList intList = new ArrayList (num); // Create individual elements or ArrayLists and add them to intList as elements ArrayList list_elem1 = new ArrayList(); list_elem1.add(10); intList.add(list_elem1); ArrayList list_elem2 = new ArrayList(); list_elem2.add(20); list_elem2.add(30); intList.add(list_elem2); ArrayList list_elem3 = new (); list_elem3.add(40); list_elem3.add(50); list_elem3.add(60); intList.add(list_elem3); System.out.println('Contents of 2D ArrayList(Nested ArrayList):'); //print the 2D ArrayList or nested ArrayList for (int i = 0; i

Production:

ArrayList bidimensionnel dans Java

Le programme ci-dessus affiche une liste de tableaux 2D. Ici, tout d'abord, nous déclarons une ArrayList de ArrayLists. Ensuite, nous définissons des ArrayLists individuelles qui serviront d'éléments individuels de ArrayList imbriquée lorsque nous ajoutons chacun de ces ArrayLists à Nested ArrayList.

Pour accéder à chaque élément de ArrayList, nous devons appeler la méthode get deux fois. Tout d'abord pour accéder à la ligne de la liste des tableaux imbriqués, puis pour accéder à l'intersection individuelle de la ligne et de la colonne.

Notez que vous pouvez augmenter les niveaux imbriqués de ArrayList pour définir des ArrayLists multidimensionnels. Par exemple, 3D ArrayList aura des ArrayLists 2D comme éléments et ainsi de suite.

Questions fréquemment posées

Q # 1) Qu'est-ce que ArrayList en Java?

Répondre: Une ArrayList en Java est un tableau dynamique. Il est de nature redimensionnable, c'est-à-dire qu'il augmente de taille lorsque de nouveaux éléments sont ajoutés et se réduit lorsque des éléments sont supprimés.

Q # 2) Quelle est la différence entre Array et ArrayList?

Répondre: Un tableau est en structure statique et sa taille ne peut pas être modifiée une fois déclarée. Un ArrayList est un tableau dynamique et change sa taille lorsque des éléments sont ajoutés ou supprimés.

Le tableau est une structure de base en Java alors qu'une ArrayList fait partie du Framework de collection en Java. Une autre différence est que si Array utilise l'indice (()) pour accéder aux éléments, ArrayList utilise des méthodes pour accéder à ses éléments.

Q # 3) ArrayList est-il une liste?

Répondre: ArrayList est un sous-type de la liste. ArrayList est une classe tandis que List est une interface.

Q # 4) ArrayList est-il une collection?

Répondre: Non. ArrayList est une implémentation de Collection qui est une interface.

Q # 5) Comment ArrayList augmente-t-il sa taille?

Répondre: En interne, ArrayList est implémenté en tant que Array. ArrayList a un paramètre de taille. Lorsque les éléments sont ajoutés à ArrayList et que la valeur de taille est atteinte, ArrayList ajoute en interne un autre tableau pour accueillir les nouveaux éléments.

Conclusion

C'était le tutoriel sur les bases de la classe ArrayList en Java. Nous avons vu la création et l'initialisation de la classe ArrayList avec une implémentation de programmation détaillée de ArrayList.

Nous avons également discuté des listes de tableaux 2D et multidimensionnelles. La classe ArrayList prend en charge les différentes méthodes que nous pouvons utiliser pour manipuler les éléments. Dans nos prochains tutoriels, nous reprendrons ces méthodes.

=> Lisez la série de formations Easy Java.

lecture recommandée

^