Commençons notre introduction à la structure de données List. Ci-dessous se trouve un organigramme illustrant la hiérarchie des collections et des listes. Il peut sembler vaste et complexe, mais nous allons l'analyser étape par étape.

Dans cette section, vous explorerez un type spécifique de collection appelé listes. Vous examinerez de plus près différents types de listes, notamment ArrayList, LinkedList et Stack.

Puisque toutes les listes héritent de l'interface List, il est possible de créer des objets en utilisant l'interface parente. Nous approfondirons ce sujet plus tard.

Pour l'instant, abordons le premier type de liste – ArrayList.

Ci-dessus, vous voyez la syntaxe pour créer un ArrayList<>. Il y a une partie qui pourrait ne pas vous être familière – le générique. Nous aborderons plus tard les génériques et leur création.

Pour l'instant, retenez simplement que lors de la création d'un ArrayList, il faut spécifier le type de données entre crochets angulaires. Gardez également à l'esprit que les listes ne peuvent pas fonctionner avec des types de données primitifs. À la place, on utilise des classes enveloppantes.

Créons maintenant une liste en code et ajoutons quelques objets à l'aide de la méthode add().

Main.java


              1234567891011121314
            
package com.example;

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> numberList = new ArrayList<>();
        numberList.add(10);
        numberList.add(15);
        numberList.add(5);
        System.out.println(numberList);
    }
}

Comme vous pouvez le constater, la méthode add() est très simple : elle ajoute simplement la valeur spécifiée à la liste.

Gardez également à l'esprit qu'il est nécessaire d'importer List et ArrayList depuis la bibliothèque java.util. Cependant, si vous utilisez IntelliJ IDEA, ces bibliothèques sont importées automatiquement, il n'est donc pas nécessaire de s'en préoccuper.

Voyons maintenant un exemple de création d'une liste avec notre type de données personnalisé :

Main.java


              1234567891011121314151617181920212223242526272829303132333435
            
package com.example;

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        Dog bob = new Dog("Bob", 2);
        Dog ben = new Dog("Ben", 1);
        Dog brian = new Dog("Brian", 5);
        List<Dog> dogList = new ArrayList<>();
        dogList.add(bob);
        dogList.add(ben);
        dogList.add(brian);
        System.out.println(dogList);
    }
}

class Dog {
    String name;
    int age;

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

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

Comme vous pouvez le constater, nous avons créé notre propre classe Dog et une ArrayList utilisant ce type de données. Lorsque nous avons affiché la liste, elle a présenté tous les objets qu'elle contient.

Que faire si vous disposez d’un tableau et que vous souhaitez le convertir en liste ? Cela est possible grâce à la méthode asList() de la classe Arrays.

Cette méthode permet de créer une liste contenant les mêmes éléments que le tableau d’origine. Elle est particulièrement utile lorsque l’on souhaite appliquer des méthodes de liste à un tableau. La syntaxe est simple :

Arrays.asList(arrayName);

Il est également possible de l’utiliser directement lors de l’initialisation d’une nouvelle liste, par exemple :

Main.java


              12345678910111213141516171819202122232425262728293031323334
            
package com.example;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        Dog bob = new Dog("Bob", 2);
        Dog ben = new Dog("Ben", 1);
        Dog brian = new Dog("Brian", 5);
        Dog[] dogs = {bob, ben, brian};
        List<Dog> dogList = new ArrayList<>(Arrays.asList(dogs));
        System.out.println(dogList);
    }
}

class Dog {
    String name;
    int age;

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

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

Tout comme il est possible de convertir un tableau en liste, il est également possible de convertir une liste en tableau à l'aide de la méthode toArray().

Méthodes ArrayList<>

Présentation des principales méthodes de liste. Jusqu'à présent, il aurait été possible de remplacer les listes par des tableaux, mais la différence essentielle réside dans les méthodes.

La méthode add() est une méthode surchargée, ce qui signifie qu'elle possède plusieurs variantes. L'une d'elles permet d'ajouter un élément à un indice spécifique.

Lorsqu'un élément est inséré au milieu d'une liste, tous les éléments situés à droite se décalent d'une position pour faire de la place au nouvel élément.

Par exemple, si un élément est ajouté au début de la liste, tous les éléments existants se décalent d'une position vers la droite.

Examinons un exemple :

Main.java


              123456789101112131415161718
            
package com.example;

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        for (int i = 0; i < 5; i++) { // Filling `numbers` list with 5 values
            numbers.add(i);
        }
        System.out.println("`numbers` before modifying: " + numbers);
        numbers.add(2, 10); // Adding 10 on the second index
        System.out.println("`numbers` after first modifying: " + numbers);
        numbers.add(0, 5);
        System.out.println("`numbers` after second modifying: " + numbers);
    }
}

La manière dont les valeurs se déplacent lors de l'insertion d'un élément peut être visualisée dans l'illustration suivante :

Récupération des éléments

Évidemment, si l'ajout d'objets à une liste à un indice spécifique est possible, la récupération d'objets par leur indice l'est également à l'aide de la méthode get(int index).

Considérons un exemple :

Main.java


              12345678910111213141516171819
            
package com.example;

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>();
        names.add("Alice");
        names.add("Bob");
        names.add("Charlie");
        names.add("David");
        names.add("Eva");

        // Retrieving element by index
        String element = names.get(2);  // Retrieving the 3rd element (index starts from 0)
        System.out.println("The element at index 2 is: " + element);
    }
}

Suppression d'éléments

Vous pouvez ajouter, vous pouvez récupérer, mais pouvez-vous supprimer ? Bien sûr ! Il est possible de supprimer des éléments en utilisant la méthode remove(int index).

Cette méthode est également surchargée, ce qui signifie qu'il existe une autre façon de supprimer un élément. Vous pouvez utiliser la méthode remove(Object obj), qui supprime la première occurrence de l'élément spécifié.

Imaginons maintenant que vous disposez d'une grande liste de tous les étudiants de notre cours. Cependant, un étudiant s'est mal comporté et a été expulsé. Vous ne connaissez pas son index exact, donc vous devez le supprimer par son nom. Mais il y a un problème : le code est un peu défectueux et son nom peut apparaître plusieurs fois dans la liste.

Écrivons un programme pour supprimer toutes les occurrences de cet étudiant de la liste :

Main.java


              123456789101112131415161718
            
package com.example;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        String[] names = {"Bob", "Alice", "Charlie", "David", "Eva", "Frank", "Grace", "Hank", "Ivy", "Jack", "Katherine", "Leo", "Mia", "Nathan", "Olivia", "Paul", "Quinn", "Rachel", "Sam", "Tom", "Ursula", "Victor", "Wendy", "Xander", "Yvonne", "Zack", "Bob", "Emily", "Bob", "Jake", "Isabel", "Liam", "Nora", "Bob", "Sophia", "Bob", "Daniel", "Gabrielle", "Mike"};
        // Expelled student: Bob
        List<String> students = new ArrayList<>(Arrays.asList(names));
        System.out.println("Is Bob present in the list? " + students.contains("Bob"));
        while (students.contains("Bob")) {
            students.remove("Bob");
        }
        System.out.println("Is Bob still present in the list after the removal operation? " + students.contains("Bob"));
    }
}

Vous avez peut-être remarqué que nous avons utilisé une autre méthode de liste—contains(Object obj). Cette méthode vérifie si l’élément spécifié est présent dans la liste et retourne true ou false.

En utilisant contains(), nous définissons la condition pour la boucle while, ce qui nous permet de supprimer toutes les occurrences d’un étudiant comme « Bob » de la liste.

D’ailleurs, il est possible de simplifier considérablement ce processus en utilisant la méthode removeAll(Collection<?> c) :

Main.java


              123456789101112131415161718
            
package com.example;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        String[] names = {"Bob", "Alice", "Charlie", "David", "Eva", "Frank", "Grace", "Hank", "Ivy", "Jack", "Katherine", "Leo", "Mia", "Nathan", "Olivia", "Paul", "Quinn", "Rachel", "Sam", "Tom", "Ursula", "Victor", "Wendy", "Xander", "Yvonne", "Zack", "Bob", "Emily", "Bob", "Jake", "Isabel", "Liam", "Nora", "Bob", "Sophia", "Bob", "Daniel", "Gabrielle", "Mike"};
        // Expelled student: Bob
        List<String> students = new ArrayList<>(Arrays.asList(names));
        System.out.println("Is Bob present in the list? " + students.contains("Bob"));
        List<String> expelledStudents = new ArrayList<>();
        expelledStudents.add("Bob");
        students.removeAll(expelledStudents);
        System.out.println("Is Bob still present in the list after the removal operation? " + students.contains("Bob"));
    }
}

La méthode removeAll() prend une collection en paramètre, contenant les valeurs qui seront supprimées de la liste sur laquelle la méthode est appelée.

Dans cette approche, nous avons créé une collection d’étudiants expulsés et y avons ajouté « Bob ». Cela rend notre code facilement extensible—il suffit d’ajouter d’autres fauteurs de troubles à la liste des étudiants expulsés au fil du temps.

Mise à jour d'une valeur par indice

Revenons aux méthodes de liste—il est maintenant temps d'aborder la méthode de mise à jour.

Étant donné que la méthode add() décale simplement tous les éléments vers la droite lors de l'insertion d'une nouvelle valeur, il nous faut une autre méthode pour mettre à jour une valeur existante par son indice.

La méthode set(int index, Object value) permet précisément cela :

Main.java


              12345678910111213141516
            
package com.example;

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> example = new ArrayList<>();
        for (int i = 1; i <= 5; i++) {
            example.add(i);
        }
        System.out.println("List before modification: " + example);
        example.set(2, 28);
        System.out.println("List after modification: " + example);
    }
}

C'est assez simple—nous avons remplacé l'élément à l'indice deux par le nombre 28.

Autres méthodes

Vous avez déjà étudié les méthodes les plus courantes, mais il en existe beaucoup d'autres. Comme elles sont rarement utilisées, nous ne nous attarderons pas sur chacune d'elles.

À la place, vous pouvez retrouver toutes les méthodes nécessaires—accompagnées de la documentation complète et d'explications détaillées—en ouvrant la classe ArrayList dans IntelliJ IDEA.

Pour cela, importez simplement la bibliothèque ArrayList, maintenez la touche Command key (Ctrl sous Windows) enfoncée, puis cliquez sur ArrayList. Vous verrez alors tous les champs et méthodes disponibles dans la classe, ce qui vous aidera à explorer les méthodes que vous auriez pu manquer.

Tout était clair ?

Merci pour vos commentaires !

Section 1. Chapitre 2

Demandez à l'IA

Posez n'importe quelle question ou essayez l'une des questions suggérées pour commencer notre discussion

Glissez pour afficher le menu

Puisque toutes les listes héritent de l'interface List, il est possible de créer des objets en utilisant l'interface parente. Nous approfondirons ce sujet plus tard.

Pour l'instant, abordons le premier type de liste – ArrayList.

Créons maintenant une liste en code et ajoutons quelques objets à l'aide de la méthode add().

Main.java


              1234567891011121314
            
package com.example;

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> numberList = new ArrayList<>();
        numberList.add(10);
        numberList.add(15);
        numberList.add(5);
        System.out.println(numberList);
    }
}

Comme vous pouvez le constater, la méthode add() est très simple : elle ajoute simplement la valeur spécifiée à la liste.

Voyons maintenant un exemple de création d'une liste avec notre type de données personnalisé :

Main.java


              1234567891011121314151617181920212223242526272829303132333435
            
package com.example;

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        Dog bob = new Dog("Bob", 2);
        Dog ben = new Dog("Ben", 1);
        Dog brian = new Dog("Brian", 5);
        List<Dog> dogList = new ArrayList<>();
        dogList.add(bob);
        dogList.add(ben);
        dogList.add(brian);
        System.out.println(dogList);
    }
}

class Dog {
    String name;
    int age;

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

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

Que faire si vous disposez d’un tableau et que vous souhaitez le convertir en liste ? Cela est possible grâce à la méthode asList() de la classe Arrays.

Arrays.asList(arrayName);

Il est également possible de l’utiliser directement lors de l’initialisation d’une nouvelle liste, par exemple :

Main.java


              12345678910111213141516171819202122232425262728293031323334
            
package com.example;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        Dog bob = new Dog("Bob", 2);
        Dog ben = new Dog("Ben", 1);
        Dog brian = new Dog("Brian", 5);
        Dog[] dogs = {bob, ben, brian};
        List<Dog> dogList = new ArrayList<>(Arrays.asList(dogs));
        System.out.println(dogList);
    }
}

class Dog {
    String name;
    int age;

    public Dog(String name, int age) {
        this.name = name;
        this.age = age;
    }

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

Tout comme il est possible de convertir un tableau en liste, il est également possible de convertir une liste en tableau à l'aide de la méthode toArray().

Méthodes ArrayList<>

La méthode add() est une méthode surchargée, ce qui signifie qu'elle possède plusieurs variantes. L'une d'elles permet d'ajouter un élément à un indice spécifique.

Lorsqu'un élément est inséré au milieu d'une liste, tous les éléments situés à droite se décalent d'une position pour faire de la place au nouvel élément.

Par exemple, si un élément est ajouté au début de la liste, tous les éléments existants se décalent d'une position vers la droite.

Examinons un exemple :

Main.java


              123456789101112131415161718
            
package com.example;

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> numbers = new ArrayList<>();
        for (int i = 0; i < 5; i++) { // Filling `numbers` list with 5 values
            numbers.add(i);
        }
        System.out.println("`numbers` before modifying: " + numbers);
        numbers.add(2, 10); // Adding 10 on the second index
        System.out.println("`numbers` after first modifying: " + numbers);
        numbers.add(0, 5);
        System.out.println("`numbers` after second modifying: " + numbers);
    }
}

La manière dont les valeurs se déplacent lors de l'insertion d'un élément peut être visualisée dans l'illustration suivante :

Récupération des éléments

Évidemment, si l'ajout d'objets à une liste à un indice spécifique est possible, la récupération d'objets par leur indice l'est également à l'aide de la méthode get(int index).

Considérons un exemple :

Main.java


              12345678910111213141516171819
            
package com.example;

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<String> names = new ArrayList<>();
        names.add("Alice");
        names.add("Bob");
        names.add("Charlie");
        names.add("David");
        names.add("Eva");

        // Retrieving element by index
        String element = names.get(2);  // Retrieving the 3rd element (index starts from 0)
        System.out.println("The element at index 2 is: " + element);
    }
}

Suppression d'éléments

Vous pouvez ajouter, vous pouvez récupérer, mais pouvez-vous supprimer ? Bien sûr ! Il est possible de supprimer des éléments en utilisant la méthode remove(int index).

Écrivons un programme pour supprimer toutes les occurrences de cet étudiant de la liste :

Main.java


              123456789101112131415161718
            
package com.example;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        String[] names = {"Bob", "Alice", "Charlie", "David", "Eva", "Frank", "Grace", "Hank", "Ivy", "Jack", "Katherine", "Leo", "Mia", "Nathan", "Olivia", "Paul", "Quinn", "Rachel", "Sam", "Tom", "Ursula", "Victor", "Wendy", "Xander", "Yvonne", "Zack", "Bob", "Emily", "Bob", "Jake", "Isabel", "Liam", "Nora", "Bob", "Sophia", "Bob", "Daniel", "Gabrielle", "Mike"};
        // Expelled student: Bob
        List<String> students = new ArrayList<>(Arrays.asList(names));
        System.out.println("Is Bob present in the list? " + students.contains("Bob"));
        while (students.contains("Bob")) {
            students.remove("Bob");
        }
        System.out.println("Is Bob still present in the list after the removal operation? " + students.contains("Bob"));
    }
}

En utilisant contains(), nous définissons la condition pour la boucle while, ce qui nous permet de supprimer toutes les occurrences d’un étudiant comme « Bob » de la liste.

D’ailleurs, il est possible de simplifier considérablement ce processus en utilisant la méthode removeAll(Collection<?> c) :

Main.java


              123456789101112131415161718
            
package com.example;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        String[] names = {"Bob", "Alice", "Charlie", "David", "Eva", "Frank", "Grace", "Hank", "Ivy", "Jack", "Katherine", "Leo", "Mia", "Nathan", "Olivia", "Paul", "Quinn", "Rachel", "Sam", "Tom", "Ursula", "Victor", "Wendy", "Xander", "Yvonne", "Zack", "Bob", "Emily", "Bob", "Jake", "Isabel", "Liam", "Nora", "Bob", "Sophia", "Bob", "Daniel", "Gabrielle", "Mike"};
        // Expelled student: Bob
        List<String> students = new ArrayList<>(Arrays.asList(names));
        System.out.println("Is Bob present in the list? " + students.contains("Bob"));
        List<String> expelledStudents = new ArrayList<>();
        expelledStudents.add("Bob");
        students.removeAll(expelledStudents);
        System.out.println("Is Bob still present in the list after the removal operation? " + students.contains("Bob"));
    }
}

La méthode removeAll() prend une collection en paramètre, contenant les valeurs qui seront supprimées de la liste sur laquelle la méthode est appelée.

Mise à jour d'une valeur par indice

Revenons aux méthodes de liste—il est maintenant temps d'aborder la méthode de mise à jour.

La méthode set(int index, Object value) permet précisément cela :

Main.java


              12345678910111213141516
            
package com.example;

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Integer> example = new ArrayList<>();
        for (int i = 1; i <= 5; i++) {
            example.add(i);
        }
        System.out.println("List before modification: " + example);
        example.set(2, 28);
        System.out.println("List after modification: " + example);
    }
}

C'est assez simple—nous avons remplacé l'élément à l'indice deux par le nombre 28.

Autres méthodes

Vous avez déjà étudié les méthodes les plus courantes, mais il en existe beaucoup d'autres. Comme elles sont rarement utilisées, nous ne nous attarderons pas sur chacune d'elles.

Tout était clair ?

Merci pour vos commentaires !

Section 1. Chapitre 2

Liste et ArrayList en Java

Méthodes ArrayList<>

Récupération des éléments

Suppression d'éléments

Mise à jour d'une valeur par indice

Autres méthodes

1. Quelle méthode permet d’ajouter un élément à un index donné ?

2. Quelle méthode permet de récupérer un élément à partir de son index ?

3. Quelle méthode pouvons-nous utiliser pour supprimer la première occurrence d’un élément ?

4. Quelle méthode pouvons-nous utiliser pour remplacer un élément par son indice ?

5. Quelle méthode pouvons-nous utiliser pour vérifier la présence d’un élément ?

6. Peut-on créer une liste à partir d’un tableau ?

7. Comment peut-on créer une liste à partir d’un tableau ?

Liste et ArrayList en Java

Méthodes ArrayList<>

Récupération des éléments

Suppression d'éléments

Mise à jour d'une valeur par indice

Autres méthodes

1. Quelle méthode permet d’ajouter un élément à un index donné ?

2. Quelle méthode permet de récupérer un élément à partir de son index ?

3. Quelle méthode pouvons-nous utiliser pour supprimer la première occurrence d’un élément ?

4. Quelle méthode pouvons-nous utiliser pour remplacer un élément par son indice ?

5. Quelle méthode pouvons-nous utiliser pour vérifier la présence d’un élément ?

6. Peut-on créer une liste à partir d’un tableau ?

7. Comment peut-on créer une liste à partir d’un tableau ?