Java

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);
                            
 Remarque !  Si vous savez que vous aurez besoin de plus de 10 éléments au départ, il est plus efficace de créer une liste de tableaux avec une plus grande capacité.

Le tableau suivant résume quelques méthodes utiles ArrayList.

MéthodeDescription
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);
                                        }
                                    }
                            
[1, 4, 5, 2]
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, 5, 2]
[[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, 5, 2]
[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));
                                        }
                                    }
                            
5
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());
                                        }
                                    }
                            
la taille est : 3

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 non triée : [4, 5, 2]
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.

Partager ce cours avec tes amis :

Rédigé par M. ESSADDOUKI

Learning a new programming language is an easy thing, but the most difficult thing is how to design efficient algorithms for real-world problems, so don't be a programmer, be a problems solver.

Cours Similaires :