Java List : méthodes et applications importantes

Une List en Java est particulièrement appropriée pour les scénarios dans lesquels la taille du volume de données n’est pas connue au préalable ou peut évoluer au fil du temps. Nous vous présentons des exemples concrets d’utilisation des listes, ainsi que les opérations que vous pouvez exécuter en association.

À quoi servent les listes en Java ?

Les listes sont l’une des structures de données basiques de la programmation Java et possèdent une large gamme d’applications. Elles contiennent des éléments ordonnés pouvant être ajoutés, modifiés, supprimés ou extraits. Les objets d’une liste Java peuvent appartenir à plusieurs classes. Il est également possible d’enregistrer des éléments vides ou en doublon. Par ailleurs, les listes Java sont compatibles avec des classes et méthodes génériques, ce qui garantit la sécurité des types.

Les listes sont par exemple appliquées dans des bases de données dans lesquelles elles servent à conserver d’importants volumes de données à partir des requêtes de bases de données et d’y accéder. Les listes Java sont souvent utilisées dans les interfaces utilisateur graphiques pour afficher une liste d’éléments, par exemple les options d’un menu déroulant ou les différents articles d’une boutique en ligne.

La liste Java est également indispensable dans les algorithmes et les structures de données. Elle est utilisée lors de la mise en œuvre d’algorithmes de tri, d’algorithmes de recherche ou de structures de files d’attente et de piles. Dans les applications réseau, les listes peuvent contribuer à faciliter la gestion des associations et des prises.

Les méthodes de Java List

Java List fait partie de l’interface Collections et doit être importée à partir du package java.util. Les classes de mise en œuvre incluent notamment les éléments Java ArrayList, LinkedList, Vector et Stack. Vous pouvez déclarer les différentes instances de la liste de la manière suivante :

List linkedList = new LinkedList(); // LinkedList
List arrayList = new ArrayList(); // ArrayList
List vecList = new Vector(); // Vector
List stackList = new Stack(); //Stack

Voici quelques-unes des méthodes les plus importantes utilisées en lien avec les listes Java :

1. int size() : détermine le nombre d’éléments dans une liste.
2. void add(int index, E element) : ajoute un élément à une position spécifique.
3. boolean isEmpty() : vérifie que la liste est vide.
4. void clear() : supprime tous les éléments de la liste.
5. boolean contains(Object o) : retourne la valeur « true » si l’objet « o » est présent.
6. boolean add(E e) : ajoute l’élément indiqué à la fin de la liste.
7. boolean remove(Object o) : supprime la première instance d’un élément spécifique.
8. E get(int index) : retourne l’élément à la position indiquée.
9. E set(int index, E element) : remplace ou insère un élément à la position respective.
10. Object[] toArray() : retourne un array avec les éléments de la liste.
11. List<E> subList(int fromIndex, int toIndex) : répertorie tous les éléments de l’intervalle défini.
12. default void replaceAll(UnaryOperator<E> operator) : méthode standard en Java 8 qui applique à chaque élément des opérateurs Java unaires et remplace le résultat avec l’élément correspondant.

Applications typiques des listes Java

Nous vous présentons ci-après les applications les plus courantes d’une liste Java. Parmi celles-ci figurent les conversions d’arrays en listes et vice versa, ainsi que les tris, les appels ou les modifications d’éléments.

Convertir un array en une liste

Pour convertir un array, vous pouvez exécuter une liste avec des boucles et ajouter tour à tour les éléments de l’array grâce à la méthode « .add() ».

    import java.util.*;
    public class ArrayToList{
      public static void main(String args[]){
      // Création d’un array
      String[] colors={"blue","green","red","yellow"};
      System.out.println("Array: "+Arrays.toString(colors));
      //Conversion de l’array en liste
      List<String> list=new ArrayList<String>();
      for(String color: colors){
        list.add(color);
      }
      System.out.println("List: "+list);
      }
    }

Le résultat est le suivant :

Array: [blue, green, red, yellow]
List: [blue, green, red, yellow]

Convertir une liste en un array

Grâce à la méthode « toArray() », une liste peut être transformée en un array :

    import java.util.*;
    public class ListToArray{
      public static void main(String args[]){
       List<String> days = new ArrayList<String>();
       days.add("Monday");
       days.add("Tuesday");
       days.add("Wednesday");
       days.add("Thursday");
       days.add("Friday");
       days.add("Saturday");
       days.add("Sunday");
       // Conversion d’un ArrayList en array
       String[] array = days.toArray(new String[days.size()]);
       System.out.println("Array: "+Arrays.toString(array));
       System.out.println("List: "+days);
      }
    }

Dans le résultat, nous constatons que le contenu de l’array et celui de la liste sont identiques :

Array: [Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday]
List: [Monday, Tuesday, Wednesday, Thursday, Friday, Saturday, Sunday]

Appeler des éléments d’une Java List et les modifier

Grâce à la méthode « get() », vous pouvez accéder à un élément situé à une position spécifique tandis qu’avec « set() », un objet peut être remplacé et ajouté à la position souhaitée.

    import java.util.*;
    public class ListExample{
      public static void main(String args[]){
      // Création d’une liste
      List<String> letters=new ArrayList<String>();
      // Ajout d’éléments
      letters.add("a");
      letters.add("b");
      letters.add("c");
      // get()
      System.out.println("Element at index 1: "+letters.get(1));
      // set()
      letters.set(2, "d");
      for(String letter: letters)
      System.out.println(letter);
      }
    }

Le comptage débutant à la position 0 sous Java, le résultat obtenu est donc le suivant :

Element at index 1: b
a
b
d

Trier une liste

Pour trier une liste Java, nous pouvons utiliser la méthode « .sort() » de la classe Collections. Nous exécutons une itération à l’aide d’une boucle dans la liste, puis transmettons un par un les éléments à l’écran :

    import java.util.*;
    class SortArrayList{
      public static void main(String args[]){
      // Création d’une liste de chiffres
      List<Integer> numbers=new ArrayList<Integer>();
      numbers.add(4);
      numbers.add(57);
      numbers.add(92);
      numbers.add(26);
      // Tri
      Collections.sort(numbers);
      for(Integer number: numbers)
        System.out.println(number);
      }
    }

Les chiffres de la liste Java sont triés dans l’ordre croissant et ainsi affichés à l’écran :

4
26
57
92