Une List en Java est par­ti­cu­liè­re­ment ap­pro­prié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é­sen­tons des exemples concrets d’uti­li­sa­tion des listes, ainsi que les opé­ra­tions que vous pouvez exécuter en as­so­cia­tion.

À quoi servent les listes en Java ?

Les listes sont l’une des struc­tures de données basiques de la pro­gram­ma­tion Java et possèdent une large gamme d’ap­pli­ca­tions. Elles con­tien­nent des éléments ordonnés pouvant être ajoutés, modifiés, supprimés ou extraits. Les objets d’une liste Java peuvent ap­par­te­nir à plusieurs classes. Il est également possible d’en­re­gis­trer des éléments vides ou en doublon. Par ailleurs, les listes Java sont com­pa­tibles avec des classes et méthodes gé­né­riques, ce qui garantit la sécurité des types.

Les listes sont par exemple ap­pli­quées dans des bases de données dans les­quelles elles servent à conserver d’im­por­tants 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 in­ter­faces uti­li­sa­teur gra­phiques pour afficher une liste d’éléments, par exemple les options d’un menu déroulant ou les dif­fé­rents articles d’une boutique en ligne.

La liste Java est également in­dis­pen­sable dans les al­go­rithmes et les struc­tures de données. Elle est utilisée lors de la mise en œuvre d’al­go­rithmes de tri, d’al­go­rithmes de recherche ou de struc­tures de files d’attente et de piles. Dans les ap­pli­ca­tions réseau, les listes peuvent con­tri­buer à faciliter la gestion des as­so­cia­tions et des prises.

Les méthodes de Java List

Java List fait partie de l’interface Col­lec­tions et doit être importée à partir du package java.util. Les classes de mise en œuvre incluent notamment les éléments Java ArrayList, Lin­ked­List, Vector et Stack. Vous pouvez déclarer les dif­fé­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
Java

Voici quelques-unes des méthodes les plus im­por­tantes 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é­ci­fique.
  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é­ci­fique.
  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 res­pec­tive.
  10. Object[] toArray() : retourne un array avec les éléments de la liste.
  11. List<E> subList(int fromIndex, int toIndex) : ré­per­to­rie tous les éléments de l’in­ter­valle défini.
  12. default void replaceAll(UnaryOperator<E> operator) : méthode standard en Java 8 qui applique à chaque élément des opé­ra­teurs Java unaires et remplace le résultat avec l’élément cor­res­pon­dant.

Ap­pli­ca­tions typiques des listes Java

Nous vous pré­sen­tons ci-après les ap­pli­ca­tions les plus courantes d’une liste Java. Parmi celles-ci figurent les con­ver­sions d’arrays en listes et vice versa, ainsi que les tris, les appels ou les mo­di­fi­ca­tions 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);
      }
    }
Java

Le résultat est le suivant :

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

Convertir une liste en un array

Grâce à la méthode « toArray() », une liste peut être trans­for­mé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);
      }
    }
Java

Dans le résultat, nous cons­ta­tons que le contenu de l’array et celui de la liste sont iden­tiques :

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

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é­ci­fique 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);
      }
    }
Java

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
Java

Trier une liste

Pour trier une liste Java, nous pouvons utiliser la méthode « .sort() » de la classe Col­lec­tions. Nous exécutons une itération à l’aide d’une boucle dans la liste, puis trans­met­tons 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);
      }
    }
Java

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

4
26
57
92
Java

ff5bfb05950a260d5f5d3a067f89c3e4

Aller au menu principal