Liste de tableaux Java fait partie de Java cadre de collecte et c'est une classe du 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. Le principal avantage de ArrayList en Java c'est-à-dire que si nous déclarons un tableau, nous devons mentionner la taille, mais dans ArrayList, il n'est pas nécessaire de mentionner la taille d'ArrayList. Si vous souhaitez mentionner la taille, vous pouvez le faire.

Table des matières

dormir pour javascript

• Qu’est-ce qu’ArrayList en Java ?
• Exemple de liste de tableaux Java
• Fonctionnalités importantes de ArrayList en Java
• Constructeurs dans ArrayList
• ArrayList dans les méthodes Java
• Opérations effectuées dans ArrayList
• Complexité de Java ArrayList
• Avantages de Java ArrayList
• Inconvénients de Java ArrayList
• Conclusion
• FAQ sur ArrayList

Qu’est-ce qu’ArrayList en Java ?

ArrayList est une classe Java implémentée à l'aide de l'interface List. Java ArrayList, comme son nom l'indique, fournit la fonctionnalité d'un tableau dynamique dont la taille n'est pas fixe comme un tableau. De plus, en tant que partie intégrante du framework Collections, il possède de nombreuses fonctionnalités non disponibles avec les tableaux.

Illustration:

Vérifions l'ArrayList avec le type d'objet Integer stocké dedans avec une image.

Exemple de liste de tableaux Java

Exemple 1: L'implémentation suivante montre comment créer et utiliser une ArrayList avec une mention de sa taille.

// Java program to demonstrate the // working of ArrayList import java.io.*; import java.util.*; class ArrayListExample {  public static void main(String[] args)  {  // Size of the  // ArrayList  int n = 5;  // Declaring the ArrayList with  // initial size n  ArrayList arr1 = nouvelle liste de tableaux (n);  // Déclaration de la ArrayList ArrayList arr2 = nouvelle liste de tableaux ();  // Impression de l'ArrayList System.out.println('Array 1:' + arr1);  System.out.println('Array 2:' + arr2);  // Ajout de nouveaux éléments à // la fin de la liste pour (int i = 1; i<= n; i++) {  arr1.add(i);  arr2.add(i);  }  // Printing the ArrayList  System.out.println('Array 1:' + arr1);  System.out.println('Array 2:' + arr2);  } }>

Array 1:[] Array 2:[] Array 1:[1, 2, 3, 4, 5] Array 2:[1, 2, 3, 4, 5]>

Explication du programme ci-dessus :

ArrayList est un tableau dynamique et nous n'avons pas besoin de spécifier la taille lors de sa création, la taille du tableau augmente automatiquement lorsque nous ajoutons et supprimons dynamiquement des éléments. Bien que l'implémentation réelle de la bibliothèque puisse être plus complexe, voici une idée très basique expliquant le fonctionnement du tableau lorsque le tableau est plein et si nous essayons d'ajouter un élément :

• Crée une mémoire de plus grande taille sur la mémoire tas (par exemple une mémoire de taille double).
• Copie les éléments de mémoire actuels dans la nouvelle mémoire.
• Le nouvel élément est ajouté maintenant car il y a maintenant plus de mémoire disponible.
• Supprimez l'ancienne mémoire.

Fonctionnalités importantes de ArrayList en Java

• ArrayList hérite Liste abstraite classe et implémente la Interface de liste .
• ArrayList est initialisé par taille. Cependant, la taille augmente automatiquement si la collection s'agrandit ou diminue si le objets sont retirés de la collection.
• Java ArrayList nous permet d'accéder aléatoirement à la liste.
• ArrayList ne peut pas être utilisé pour classe d'emballage pour de tels cas.
• ArrayList en Java peut être considéré comme un vecteur en C++ .
• ArrayList n'est pas synchronisé. Sa classe synchronisée équivalente en Java est Vecteur .

Comprenons le Java ArrayList en profondeur . Regardez l'image ci-dessous :

Dans l'illustration ci-dessus, Liste abstraite , CopyOnWriteArrayList , et RésuméSequentialList sont les classes qui implémentent l'interface de liste. Une fonctionnalité distincte est implémentée dans chacune des classes mentionnées. Ils sont:

1. Liste des résumés : Cette classe est utilisée pour implémenter une liste non modifiable, pour laquelle il suffit d'étendre cette classe AbstractList et d'implémenter uniquement la obtenir() et le taille() méthodes.
2. CopieOnWriteArrayList : Cette classe implémente l'interface de liste. Il s'agit d'une version améliorée de Liste des tableaux dans lequel toutes les modifications (ajouter, définir, supprimer, etc.) sont implémentées en faisant une nouvelle copie de la liste.
3. Liste séquentielle abstraite : Cette classe implémente le Interface de collecte et la classe AbstractCollection. Cette classe est utilisée pour implémenter une liste non modifiable, pour laquelle il suffit d'étendre cette classe AbstractList et d'implémenter uniquement la obtenir() et le taille() méthodes.

Constructeurs dans ArrayList en Java

Afin de créer une ArrayList, nous devons créer un objet de la classe ArrayList. La classe ArrayList se compose de divers constructeurs qui permettent la création éventuelle de la liste des tableaux. Voici les constructeurs disponibles dans cette classe :

1. ArrayList()

Ce constructeur est utilisé pour construire une liste de tableaux vides. Si nous souhaitons créer une ArrayList vide avec le nom arr , alors, il peut être créé comme :

ArrayList arr = new ArrayList();>

2. ArrayList (Collection c)

Ce constructeur permet de construire une liste de tableaux initialisée avec les éléments de la collection c. Supposons que nous souhaitions créer un arr ArrayList qui contient les éléments présents dans la collection c, alors il peut être créé comme :

ArrayList arr = new ArrayList(c);>

3. ArrayList (capacité int)

Ce constructeur est utilisé pour créer une liste de tableaux avec la capacité initiale spécifiée. Supposons que nous souhaitions créer une ArrayList dont la taille initiale est N, elle peut alors être créée comme :

ArrayList arr = new ArrayList(N);>

Méthodes Java ArrayList

Note: Vous pouvez également créer une ArrayList générique :

// Création d'un ArrayList entier générique
ArrayList arrli = new ArrayList();

Quelques points clés d'ArrayList en Java

1. ArrayList est un tableau redimensionnable à structure de données soulignée ou un tableau évolutif.
2. Les doublons ArrayList sont autorisés.
3. L’ordre d’insertion est conservé.
4. Les objets hétérogènes sont autorisés.
5. L'insertion nulle est possible.

Voyons comment effectuer certaines opérations de base sur ArrayList, comme indiqué, dont nous allons discuter plus en détail parallèlement à la mise en œuvre de chaque opération.

• Ajout d'un élément à la liste/Ajouter un élément
• Éléments changeants/élément de réglage
• Supprimer des éléments/Supprimer un élément
• Éléments itératifs
• obtenir des éléments
• ajouter des éléments entre deux nombres
• Trier les éléments
• Taille de la liste de tableaux

Opérations effectuées dans ArrayList

1. Ajout d'éléments

Afin d'ajouter un élément à une ArrayList, nous pouvons utiliser le méthode ajouter() . Cette méthode est surchargée pour effectuer plusieurs opérations basées sur différents paramètres. Ils sont les suivants :

• add(Object) : Cette méthode est utilisée pour ajouter un élément à la fin de ArrayList.
• add(int index, Object) : Cette méthode est utilisée pour ajouter un élément à un index spécifique dans ArrayList.

Vous trouverez ci-dessous la mise en œuvre de l’approche ci-dessus :

// Java Program to Add elements to An ArrayList // Importing all utility classes import java.util.*; // Main class class GFG {  // Main driver method  public static void main(String args[])  {  // Creating an Array of string type  ArrayListal = new ArrayList();  // Ajout d'éléments à ArrayList // Entrées personnalisées al.add('Geeks');  al.add('Geeks');  // Nous mentionnons ici l'index // auquel il doit être ajouté al.add(1, 'For');  // Impression de tous les éléments d'une ArrayList System.out.println(al);  } }>

[Geeks, For, Geeks]>

2. Changer les éléments

Après avoir ajouté les éléments, si l'on souhaite changer l'élément, cela peut être fait en utilisant le ensemble() méthode. Puisqu'une ArrayList est indexée, l'élément que l'on souhaite modifier est référencé par l'index de l'élément. Par conséquent, cette méthode prend un index et l'élément mis à jour qui doit être inséré à cet index.

Vous trouverez ci-dessous la mise en œuvre de l’approche ci-dessus :

// Java Program to Change elements in ArrayList // Importing all utility classes import java.util.*; // main class class GFG {  // Main driver method  public static void main(String args[])  {  // Creating an Arraylist object of string type  ArrayListal = new ArrayList();  // Ajout d'éléments à Arraylist // Éléments d'entrée personnalisés al.add('Geeks');  al.add('Geeks');  // Ajout en précisant l'index à ajouter al.add(1, 'Geeks');  // Impression des éléments Arraylist System.out.println('Initial ArrayList ' + al);  // Définition de l'élément au 1er index al.set(1, 'For');  // Impression de l'Arraylist mise à jour System.out.println('Updated ArrayList ' + al);  } }>

Initial ArrayList [Geeks, Geeks, Geeks] Updated ArrayList [Geeks, For, Geeks]>

3. Suppression d'éléments

Afin de supprimer un élément d’une ArrayList, nous pouvons utiliser le méthode supprimer() . Cette méthode est surchargée pour effectuer plusieurs opérations basées sur différents paramètres. Ils sont les suivants :

• supprimer (Objet): Cette méthode est utilisée pour simplement supprimer un objet de l'ArrayList. S'il existe plusieurs objets de ce type, la première occurrence de l'objet est supprimée.
• supprimer (index int): Puisqu'une ArrayList est indexée, cette méthode prend une valeur entière qui supprime simplement l'élément présent à cet index spécifique dans l'ArrayList. Après avoir supprimé l'élément, tous les éléments sont déplacés vers la gauche pour remplir l'espace et les index des objets sont mis à jour.

Exemple:

// Java program to Remove Elements in ArrayList // Importing all utility classes import java.util.*; // Main class class GFG {  // Main driver method  public static void main(String args[])  {  // Creating an object of arraylist class  ArrayListal = new ArrayList();  // Ajout d'éléments à ArrayList // Ajout personnalisé al.add('Geeks');  al.add('Geeks');  // Ajout d'un élément à un index spécifique al.add(1, 'For');  // Impression de tous les éléments d'ArrayList System.out.println('Initial ArrayList ' + al);  // Suppression d'un élément ci-dessus ArrayList al.remove(1);  // Impression des éléments Arraylist mis à jour System.out.println('Après la suppression de l'index ' + al);  // Suppression de cet élément de mot dans ArrayList al.remove('Geeks');  // Impression de l'ArrayList mis à jour System.out.println('Après la suppression de l'objet ' + al);  } }>

Initial ArrayList [Geeks, For, Geeks] After the Index Removal [Geeks, Geeks] After the Object Removal [Geeks]>

4. Itération de la ArrayList

Il existe plusieurs façons de parcourir ArrayList. Les méthodes les plus connues consistent à utiliser les méthodes de base pour la boucle en combinaison avec un méthode get() pour obtenir l'élément à un index spécifique et le avancé pour une boucle .

Exemple

// Java program to Iterate the elements // in an ArrayList // Importing all utility classes import java.util.*; // Main class class GFG {  // Main driver method  public static void main(String args[])  {  // Creating an Arraylist of string type  ArrayListal = new ArrayList();  // Ajout d'éléments à ArrayList // en utilisant la méthode standard add() al.add('Geeks');  al.add('Geeks');  al.add(1, 'Pour');  // Utilisation de la méthode Get et de la // boucle for for (int i = 0; i< al.size(); i++) {  System.out.print(al.get(i) + ' ');  }  System.out.println();  // Using the for each loop  for (String str : al)  System.out.print(str + ' ');  } }>

Geeks For Geeks Geeks For Geeks>

5. Obtenez des éléments

// Java program to get the elemens in ArrayList import java.io.*; import java.util.*; class GFG {  public static void main (String[] args) {  ArrayList liste = new ArrayList();  // ajoute le numéro list.add(9);  list.add(5);  list.add(6);  System.out.println(liste);  // Récupère la méthode Integer n= list.get(1);  System.out.println('à l'index 1, le numéro est :'+n);  } }>

[9, 5, 6] at indext 1 number is:5>

6. Ajouter des éléments entre deux nombres

// Java program to add the elements  // between two numbers in ArrayList import java.io.*; import java.util.*; class GFG {  public static void main(String[] args)  {  ArrayList liste = new ArrayList();  list.add(1);  list.add(2);  list.add(4);  System.out.println(liste);  // insère l'élément manquant 3 list.add(2, 3);  System.out.println(liste);  } }>

[1, 2, 4] [1, 2, 3, 4]>

7. Tri de liste de tableaux

// Java Program for ArrayList Sorting import java.io.*; import java.util.*; class GFG {  public static void main(String[] args)  {  ArrayList liste = new ArrayList();  list.add(2);  list.add(4);  list.add(3);  list.add(1);  System.out.println('Avant de trier la liste :');  System.out.println(liste);  Collections.sort(liste);  System.out.println('après tri de la liste :');  System.out.println(liste);  } }>

Before sorting list: [2, 4, 3, 1] after sorting list: [1, 2, 3, 4]>

8. Taille des éléments

// Java program to find the size  // of elements of an ArrayList import java.io.*; import java.util.*; class GFG {  public static void main(String[] args)  {  ArrayList liste = new ArrayList();  list.add(1);  list.add(2);  list.add(3);  list.add(4);  int b = liste.size();  System.out.println('La taille est :' + b);  } }>

The size is :4>

Complexité de Java ArrayList

ArrayList en Java est une classe du framework Java Collections qui implémente l'interface List. Voici les avantages et les inconvénients de l’utilisation d’ArrayList en Java.

Avantages de Java ArrayList

1. Taille dynamique : ArrayList peut augmenter et diminuer de manière dynamique, ce qui facilite l'ajout ou la suppression d'éléments selon les besoins.
2. Facile à utiliser : ArrayList est simple à utiliser, ce qui en fait un choix populaire pour de nombreux développeurs Java.
3. Accès rapide : ArrayList offre un accès rapide aux éléments, car il est implémenté sous forme de tableau sous le capot.
4. Collection ordonnée : ArrayList préserve l'ordre des éléments, vous permettant d'accéder aux éléments dans l'ordre dans lequel ils ont été ajoutés.
5. Prend en charge les valeurs nulles : ArrayList peut stocker des valeurs nulles, ce qui le rend utile dans les cas où l'absence d'une valeur doit être représentée.

Inconvénients de Java ArrayList

1. Plus lent que les tableaux : ArrayList est plus lent que les tableaux pour certaines opérations, comme l'insertion d'éléments au milieu de la liste.
2. Utilisation accrue de la mémoire : ArrayList nécessite plus de mémoire que les tableaux, car il doit conserver sa taille dynamique et gérer le redimensionnement.
3. Non thread-safe : ArrayList n'est pas thread-safe, ce qui signifie que plusieurs threads peuvent accéder et modifier la liste simultanément, ce qui entraîne des conditions de concurrence potentielles et une corruption des données.
4. Dégradation des performances : les performances d'ArrayList peuvent se dégrader à mesure que le nombre d'éléments dans la liste augmente, en particulier pour des opérations telles que la recherche d'éléments ou l'insertion d'éléments au milieu de la liste.

Conclusion

Les points à retenir de cet article sont mentionnés ci-dessous :

• ArrayList fait partie du framework Collections. Il hérite de la classe AbstractList et implémente l'interface List.
• ArrayList est l'implémentation d'un tableau dynamique.
• ArrayList peut être initialisé en utilisant différents types de constructeurs, comme sans paramètres, en passant une collection en tant que paramètre et en passant un entier en tant que paramètre.
• Les opérations peuvent être effectuées dans ArrayList comme suit : ajout, suppression, itération et tri.

FAQ sur ArrayList

Qu’est-ce qu’une ArrayList en Java ?

ArrayList en Java fait partie du framework Collections. Il est utilisé pour stocker des éléments et la taille est redimensionnable.

Comment les données sont-elles stockées dans ArrayList ?

ArrayList peut stocker des données jusqu'à ce que la taille d'ArrayList soit pleine, après quoi la taille d'ArrayList est doublée si nous voulons stocker plus d'éléments.

ArrayList autorise-t-il les doublons ?

Oui, ArrayList permet de stocker des valeurs en double.