Quelle est la différence entre les interfaces List et…

Les principales différences entre les interfaces List et Set en Java sont les suivantes :

Ordre des éléments :
- List conserve l'ordre d'insertion des éléments. Les éléments ont des indices commençant à 0.
- Set ne garantit pas l'ordre des éléments. Certaines implémentations peuvent avoir un ordre défini (par exemple, LinkedHashSet, TreeSet), mais l'interface Set ne l'exige pas.
Doublons :
- List permet de stocker des éléments en double.
- Set ne permet pas les doublons. Lorsqu'on tente d'ajouter un doublon, l'opération d'ajout est ignorée ou retourne false (selon l'implémentation et la méthode).
Performance :
- Les opérations d'ajout et de suppression au milieu d'un List peuvent être plus lentes (surtout pour ArrayList) que dans un Set.
- La vérification de la présence d'un élément (contains) dans un Set basé sur le hachage (HashSet) est généralement plus rapide (en moyenne O(1)) comparé à un List (en moyenne O(n)).
- Les opérations basées sur l'indice (par exemple, get, set) ne sont disponibles que dans List.
Implémentations :
- Implémentations typiques de List : ArrayList, LinkedList, Vector.
- Implémentations typiques de Set : HashSet, LinkedHashSet, TreeSet.

Voici des exemples illustrant les différences :

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

public class CollectionDifferences {

    public static void main(String[] args) {

        // List permet les doublons et conserve l'ordre
        List<String> list = new ArrayList<>();
        list.add("Apple");
        list.add("Banana");
        list.add("Apple"); // Ajout d'un doublon
        System.out.println("List : " + list); // Affichera [Apple, Banana, Apple]
        System.out.println("List à l'indice 1 : " + list.get(1)); // Accès par indice

        // Set ne permet pas les doublons et l'ordre n'est pas garanti (pour HashSet)
        Set<String> set = new HashSet<>();
        set.add("Apple");
        set.add("Banana");
        set.add("Apple"); // Tentative d'ajout d'un doublon - sera ignorée
        System.out.println("Set : " + set); // Affichera quelque chose comme [Apple, Banana] ou [Banana, Apple]
        // set.get(1); // Erreur de compilation - pas d'accès par indice
    }
}

Tableau comparatif :

Caractéristique	List	Set
Ordre	Garanti (ordre d'insertion)	Non garanti (pour HashSet, TreeSet a un ordre trié)
Doublons	Autorisés	Non autorisés
Accès par indice	Possible (`get(int index)`)	Impossible
Performance contains()	O(n) en moyenne (pour ArrayList)	O(1) en moyenne (pour HashSet)
Implémentations typiques	ArrayList, LinkedList, Vector	HashSet, LinkedHashSet, TreeSet

Quelle est la différence entre les interfaces List et Set en Java?