Java ArrayList

Salut! Dans les leçons précédentes, nous avons approfondi les tableaux et passé en revue des exemples courants d'utilisation de tableaux. Dans cette leçon, nous examinerons de plus près Java ArrayList. En général, les tableaux sont super pratiques. Et, comme vous l'avez déjà remarqué, vous pouvez faire beaucoup avec eux :) Mais les tableaux ont un certain nombre de défauts.

• Taille limitée. Vous devez savoir combien d'éléments votre tableau doit contenir au moment où vous le créez. Si vous sous-estimez, vous n'aurez pas assez d'espace. Surestimez et le tableau restera à moitié vide, ce qui est également mauvais. Après tout, vous allouez toujours plus de mémoire que nécessaire.


• Un tableau n'a pas de méthodes pour ajouter des éléments. Vous devez toujours indiquer explicitement l'index de la position où vous souhaitez ajouter un élément. Si vous spécifiez accidentellement l'index d'une position occupée par une valeur dont vous avez besoin, il sera écrasé.


• Il n'existe aucune méthode pour supprimer un élément. Une valeur ne peut être que "mise à zéro".

public class Cat {

   private String name;

   public Cat(String name) {
       this.name = name;
   }

   public static void main(String[] args) {

       Cat[] cats = new Cat[3];
       cats[0] = new Cat("Thomas");
       cats[1] = new Cat("Behemoth");
       cats[2] = new Cat("Lionel Messi");

       cats[1] = null;



       System.out.println(Arrays.toString(cats));
   }

   @Override
   public String toString() {
       return "Cat{" +
               "name='" + name + '\'' +
               '}';
   }
}

Sortie : [Cat{name='Thomas'}, null, Cat{name='Lionel Messi'}] Heureusement, les créateurs de Java sont bien conscients des avantages et des inconvénients des tableaux, et ont donc créé une structure de données très intéressante appelée Java ArrayList . Parlant aussi simplement que possible, une Java ArrayList est un tableau "gonflé" avec beaucoup de nouvelles fonctionnalités.

Comment créer une ArrayList

Il est très simple de créer :

ArrayList<Cat> cats = new ArrayList<Cat>();

Nous avons maintenant créé une liste pour stocker les objets Cat . Notez que nous ne spécifions pas la taille de la ArrayList , car elle peut se développer automatiquement. Comment est-ce possible? C'est assez simple, en fait. Cela peut vous surprendre, mais ArrayList en Java est construit sur un tableau très ordinaire :) Oui, il contient un tableau, et c'est là que nos éléments sont stockés. Mais ArrayList en Java a une façon particulière de travailler avec ce tableau :

• Lorsque le tableau interne est rempli, ArrayList crée un nouveau tableau en interne. La taille du nouveau tableau est la taille de l'ancien tableau multipliée par 1,5 plus 1.


• Toutes les données sont copiées de l'ancien tableau dans le nouveau


• L'ancien tableau est nettoyé par le ramasse-miettes.

Ce mécanisme permet à Java ArrayList (contrairement à un tableau ordinaire) d'implémenter une méthode pour ajouter de nouveaux éléments. C'est la add()méthode

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<Cat>();
   cats.add(new Cat("Behemoth"));
}

Les nouveaux éléments sont ajoutés à la fin de la liste. Maintenant, il n'y a aucun risque de déborder du tableau, donc cette méthode est totalement sûre. En passant, ArrayList peut non seulement trouver un objet par son index, mais aussi vice versa : il peut utiliser une référence pour trouver l'index d'un objet dans ArrayList ! C'est à cela que sert la méthode indexOf() : nous passons une référence à l'objet que nous voulons, et indexOf() renvoie son index :

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Behemoth");
   Cat lionel = new Cat("Lionel Messi");
   Cat fluffy = new Cat ("Fluffy");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(lionel);
   cats.add(fluffy);

   int thomasIndex = cats.indexOf(thomas);
   System.out.println(thomasIndex);
}

Sortie : 0 C'est exact. Notre objet thomas est bien stocké dans l'élément 0. Les tableaux n'ont pas que des inconvénients. Ils ont aussi des avantages incontestables. L'un d'eux est la possibilité de rechercher des éléments par index. Parce que nous pointons vers un index, c'est-à-dire vers une adresse mémoire spécifique, la recherche dans un tableau de cette manière est très rapide. ArrayListsait le faire aussi ! La méthode get() implémente ceci :

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Behemoth");
   Cat lionel = new Cat("Lionel Messi");
   Cat fluffy = new Cat ("Fluffy");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(lionel);
   cats.add(fluffy);

   Cat secondCat = cats.get(1);

   System.out.println(secondCat);
}

Sortie : Cat{name='Behemoth'} De plus, vous pouvez facilement savoir si la ArrayList contient un objet particulier. Ceci est fait en utilisant la méthode ArrayList contains() :

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Behemoth");
   Cat lionel = new Cat("Lionel Messi");
   Cat fluffy = new Cat ("Fluffy");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(lionel);
   cats.add(fluffy);

   cats.remove(fluffy);
   System.out.println(cats.contains(fluffy));
}

La méthode vérifie si le tableau interne de ArrayList contient l'élément et renvoie un booléen (vrai ou faux). Sortie : false Et une autre chose importante à propos de l'insertion. ArrayList vous permet d'utiliser un index pour insérer des éléments non seulement à la fin du tableau, mais n'importe où. Il a deux méthodes pour cela :

• ArrayList add(index int, élément Cat)
• Ensemble ArrayList (index int, élément Cat)

Comme arguments, ces deux méthodes prennent l'index de la position où vous voulez insérer, et une référence à l'objet lui-même. La différence est que l'insertion à l'aide de set() écrase l'ancienne valeur. L'insertion à l'aide de add() décale d'abord d'un élément tous les éléments de [index] à la fin du tableau, puis ajoute l'objet spécifié dans la position vide résultante.

Voici un exemple :

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Behemoth");
   Cat lionel = new Cat("Lionel Messi");
   Cat fluffy = new Cat ("Fluffy");

   cats.add(thomas);
   cats.add(behemoth);

   System.out.println(cats.toString());

   cats.set(0, lionel);// Now we have a list of 2 cats. Adding a 3rd using set

   System.out.println(cats.toString());
}

Sortie : [[Cat{name='Thomas'}, Cat{name='Behemoth'}] [Cat{name='Lionel Messi'}, Cat{name='Behemoth'}] Nous avions une liste de 2 chats . Ensuite, nous en avons inséré un autre comme élément 0 en utilisant la méthode set() . En conséquence, l'ancien élément a été remplacé par un nouveau.

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Behemoth");
   Cat lionel = new Cat("Lionel Messi");
   Cat fluffy = new Cat ("Fluffy");

   cats.add(thomas);
   cats.add(behemoth);

   System.out.println(cats.toString());

   cats.add(0, lionel);// Now we have a list of 2 cats. Adding a 3rd using add

   System.out.println(cats.toString());
}

Et ici, nous voyons que add() fonctionne différemment. Il déplace tous les éléments vers la droite, puis écrit la nouvelle valeur en tant qu'élément 0. Sortie : [Cat{name='Thomas'}, Cat{name='Behemoth'}] [Cat{name='Lionel Messi'}, Cat{name='Thomas'}, Cat{name='Behemoth'}] Pour effacer complètement la liste, nous utilisons la méthode clear() :

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();
   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Behemoth");
   Cat lionel = new Cat("Lionel Messi");
   Cat fluffy = new Cat ("Fluffy");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(lionel);
   cats.add(fluffy);

   cats.clear();

   System.out.println(cats.toString());
}

Sortie : [] Tout a été supprimé de la liste. Au fait, veuillez noter : contrairement aux tableaux, ArrayList remplace la méthode toString() et affiche déjà la liste de manière appropriée sous forme de chaînes. Avec des tableaux ordinaires, nous avons dû utiliser la classe Arrays pour cela. Et puisque j'ai mentionné Arrays : Java vous permet de "basculer" facilement entre un tableau et une ArrayList , c'est-à-dire de convertir l'un en un autre. La classe Arrays a une méthode Arrays.asList() pour cela. Nous l'utilisons pour obtenir le contenu sous forme de tableau et le transmettons à notre constructeur ArrayList :

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();


   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Behemoth");
   Cat lionel = new Cat("Lionel Messi");
   Cat fluffy = new Cat ("Fluffy");

   Cat[] catsArray = {thomas, behemoth, lionel, fluffy};

   ArrayList<Cat> catsList = new ArrayList<>(Arrays.asList(catsArray));
   System.out.println(catsList);
}

Sortie : [Cat{name='Thomas'}, Cat{name='Behemoth'}, Cat{name='Lionel Messi'}, Cat{name='Fluffy'}] Vous pouvez également aller dans la direction opposée : get un tableau à partir d'un objet ArrayList . Nous faisons cela en utilisant la méthode toArray() :

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();

   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Behemoth");
   Cat lionel = new Cat("Lionel Messi");
   Cat fluffy = new Cat ("Fluffy");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(lionel);
   cats.add(fluffy);

   Cat[] catsArray = cats.toArray(new Cat[0]);

   System.out.println(Arrays.toString(catsArray));
}

Remarque : nous avons passé un tableau vide à la méthode toArray() . Ce n'est pas une erreur. À l'intérieur de la classe ArrayList , cette méthode est implémentée de telle manière que le passage d'un tableau vide augmente ses performances. Gardez cela à l'esprit pour l'avenir (bien sûr, vous pouvez passer un tableau d'une taille spécifique ; cela fonctionnera également). Oh, à propos de la taille. La taille actuelle de la liste peut être trouvée en utilisant la méthode size() :

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>();


   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Behemoth");
   Cat lionel = new Cat("Lionel Messi");
   Cat fluffy = new Cat ("Fluffy");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(lionel);
   cats.add(fluffy);

   System.out.println(cats.size());
}

Il est important de comprendre que contrairement à la propriété length d'un tableau , la méthode ArrayList.size() renvoie le nombre réel d'éléments, et non la capacité d'origine. Après tout, nous n'avons pas spécifié de taille lors de la création de ArrayList . Cependant, vous pouvez le spécifier - ArrayList a un constructeur approprié. Mais en termes d'ajout de nouveaux éléments, cela ne change pas son comportement :

public static void main(String[] args) {

   ArrayList<Cat> cats = new ArrayList<>(2);// create an ArrayList with an initial capacity of 2


   Cat thomas = new Cat("Thomas");
   Cat behemoth = new Cat("Behemoth");
   Cat lionel = new Cat("Lionel Messi");
   Cat fluffy = new Cat ("Fluffy");

   cats.add(thomas);
   cats.add(behemoth);
   cats.add(lionel);
   cats.add(fluffy);

   System.out.println(cats.size());
}

Sortie de la console : 4 Nous avons créé une liste de 2 éléments, mais elle s'est tranquillement étendue lorsque nous en avions besoin. Une autre considération est que si nous créons une très petite liste au départ, elle devra s'étendre plus souvent, ce qui utilisera certaines ressources. Nous avons à peine abordé le processus de suppression d'éléments d'une ArrayList dans cette leçon Bien sûr, ce n'est pas parce que cela nous a échappé. Nous avons mis ce sujet dans une leçon séparée que vous rencontrerez plus tard :) Pour renforcer ce que vous avez appris, nous vous suggérons de regarder une leçon vidéo de notre cours Java