Les listes dynamiques - java.util.ArrayList
Outre la classe Arrays, Java fournit une classe ArrayList qui peut être utilisée pour créer des conteneurs qui stockent des listes d'objets. La classe ArrayList offre certains avantages par rapport à la classe Arrays. Plus précisément, une ArrayList est redimensionnable dynamiquement, ce qui signifie que sa taille peut changer pendant l'exécution du programme. Cela signifie que :
- Vous pouvez ajouter un élément à tout moment dans un conteneur ArrayList. La taille du tableau se développe automatiquement pour s'adapter au nouvel élément.
- Vous pouvez supprimer un élément à tout moment dans un conteneur ArrayList et la taille du tableau se contracte automatiquement.
Pour utiliser la classe ArrayList, vous devez utiliser l'une des instructions d'importation suivantes:
import java.util.ArrayList; import java.util.*;
Ensuite, pour déclarer une ArrayList, vous pouvez utiliser le constructeur par défaut, comme dans l’exemple suivant qui déclare une liste de String
ArrayList< String> names = new ArrayList< String>();
Une ArrayList peut contenir n'importe quel type d’objet ; L'ajout d'un type de données entre crochets fait que Java vérifie que vous affectez les types appropriés à une liste.
Vous pouvez omettre les crochets et le type de données après le nom de la classe ArrayList, mais vous recevez un avertissement vous indiquant que vous utilisez une opération non contrôlée ou non sécurisée.
Le constructeur par défaut crée une ArrayList avec une capacitée de 10 éléments. La capacité d'une ArrayList est le nombre d'éléments qu'elle peut tenir sans avoir à augmenter sa taille. Par définition, la capacité d’une ArrayList est supérieure ou égale à sa taille.
Vous pouvez également spécifier une capacité si vous le souhaitez. L’exemple suivant déclare une ArrayList qui peut contenir 20 noms.
ArrayList< String> noms = new ArrayList< String>(20);
Le tableau suivant résume quelques méthodes utiles ArrayList.
Méthode | Description |
---|---|
public void add(Object) | Ajouter un élément à une ArrayList; la version par défaut ajoute un élément au prochain emplacement disponible; une version surchargée vous permet de spécifier une position à laquelle nous voulons ajouter l'élément |
public void add(int, Object) | |
public void remove(int) | Supprimer un élément d'une ArrayList à un emplacement spécifié |
public void set(int, Object) | Modifier un élément à un emplacement spécifié dans une ArrayList |
Object get(int) | Récupérer un élément d'un emplacement spécifié dans une ArrayList |
public int size() | Renvoyer la taille actuelle de ArrayList |
Avec chacune des ces méthodes vous recevez un message d'erreur si le numéro de position n'est pas valide pour ArrayList.
Exemple 1 : add
import java.util.ArrayList; public class Test { public static void main(String args[]) { ArrayList< Integer> liste = new ArrayList< Integer>(); liste.add(4); liste.add(5); liste.add(2); liste.add(0, 1); System.out.println(liste); } }
Exemple 2 : remove
import java.util.ArrayList; public class Test { public static void main(String args[]) { ArrayList< Integer> liste = new ArrayList< Integer>(); liste.add(4); liste.add(5); liste.add(2); System.out.println(liste); liste.remove(1); System.out.println(liste); } }
[[4, 2]
Exemple 3 : set
import java.util.ArrayList; public class Test { public static void main(String args[]) { ArrayList< Integer> liste = new ArrayList< Integer>(); liste.add(4); liste.add(5); liste.add(2); System.out.println(liste); liste.set(1, 15); System.out.println(liste); } }
[4, 15, 2]
Exemple 4 : get
import java.util.ArrayList; public class Test { public static void main(String args[]) { ArrayList< Integer> liste = new ArrayList< Integer>(); liste.add(4); liste.add(5); liste.add(2); System.out.println("liste[1] : " + liste.get(1)); } }
Exemple 5 : size
import java.util.ArrayList; public class Test { public static void main(String args[]) { ArrayList< Integer> liste = new ArrayList< Integer>(); liste.add(4); liste.add(5); liste.add(2); System.out.println("la taille est : " + liste.size()); } }
Vous pouvez trier une ArrayList à l'aide de la méthode Collections.sort() et en fournissant ArrayList comme argument. Pour utiliser cette méthode, vous devez importer le package java.util.Collections en haut du fichier.
Exemple 6 : Collections.sort()
import java.util.ArrayList; import java.util.Collections; public class Test { public static void main(String args[]) { ArrayList< Integer> liste = new ArrayList< Integer>(); liste.add(4); liste.add(5); liste.add(2); System.out.println("Liste non triée : " + liste); Collections.sort(liste); System.out.println("liste triée : " + liste); } }
liste triée : [2, 4, 5]
Différences entre Tableaux et ArrayList
- Un tableau est une fonctionnalité de base fournie par Java. ArrayList fait partie du Framework Collection en Java. Par conséquent, les membres du tableau sont accessibles via [], tandis que ArrayList dispose d'un ensemble de méthodes pour accéder aux éléments et les modifier.
- Le tableau est une structure de données de taille fixe, contrairement à ArrayList. Il n'est pas nécessaire de mentionner la taille d'ArrayList lors de sa création. Même si nous spécifions une capacité initiale, nous pouvons ajouter plus d'éléments.
- Un tableau peut contenir à la fois des types de données primitifs et des objets d'une classe, en fonction de la définition du tableau. Cependant, ArrayList ne prend en charge que les les objets d’une classe, pas les types de données primitifs.
Remarque : lorsque nous faisons arraylist.add(1) ; elle convertit le type de données primitif int en un objet Integer. - Puisque ArrayList ne peut pas être créé pour les types de données primitifs, les membres de ArrayList sont toujours des références à des objets à différents emplacements de mémoire. Par conséquent, dans ArrayList, les objets réels ne sont jamais stockés à des endroits contigus, mais les références des objets réels sont stockées à des endroits contigus.
Dans les tableaux, cela dépend si les tableaux sont de type primitif ou de type objet. Dans le cas de types primitifs, les valeurs réelles sont stockées dans des emplacements contigus, mais dans le cas d'objets, l'allocation est similaire à ArrayList.