Quelle est la différence entre Set et List?

Quelle est la différence fondamentale entre les interfaces Set<E>et List<E>?

Listest une séquence ordonnée d'éléments alors Setqu'une liste distincte d'éléments n'est pas ordonnée (merci, Quinn Taylor ).

List<E>:

Une collection ordonnée (également connue sous le nom de séquence). L'utilisateur de cette interface a un contrôle précis sur l'endroit où dans la liste chaque élément est inséré. L'utilisateur peut accéder aux éléments par leur index entier (position dans la liste), et rechercher des éléments dans la liste.

Set<E>:

Une collection qui ne contient aucun élément en double. Plus formellement, les ensembles ne contiennent aucune paire d'éléments e1 et e2 tels que e1.equals (e2), et au plus un élément nul. Comme son nom l'indique, cette interface modélise l'abstraction de l'ensemble mathématique.

╔═══════════════════╦══════════════════════╦═════════════════════════════╗
║                   ║         List         ║            Set              ║
╠═══════════════════╬══════════════════════╬═════════════════════════════╣
║     Duplicates    ║          YES         ║            NO               ║
╠═══════════════════╬══════════════════════╬═════════════════════════════╣
║       Order       ║       ORDERED        ║  DEPENDS ON IMPLEMENTATION  ║
╠═══════════════════╬══════════════════════╬═════════════════════════════╣
║ Positional Access ║         YES          ║            NO               ║ 
╚═══════════════════╩══════════════════════╩═════════════════════════════╝

Listes ordonnées d'éléments (uniques ou non)
Conforme à l'interface Java nomméeList
Accessible par index

implémenté à l'aide

• LinkedList
• Liste des tableaux

Listes d'éléments uniques:
Conformes à l'interface Java nomméeSet
peut pas être consulté par index

implémenté à l'aide

• HashSet (non ordonné)
• LinkedHashSet (commandé)
• TreeSet (trié par ordre naturel ou par comparateur fourni)

Les deux interfaces Setet Listconformes à l'interface de Java nomméeCollection

Un ensemble ne peut pas contenir d'éléments en double alors qu'une liste le peut. Une liste (en Java) implique également l'ordre.

• Une liste est un regroupement ordonné d'articles
• Un ensemble est un regroupement non ordonné d'articles sans doublons autorisés (généralement)

Conceptuellement, nous nous référons généralement à un regroupement non ordonné qui autorise les doublons en tant que sac et ne permet pas les doublons est un ensemble.

liste

1. Est un regroupement ordonné d'éléments.
2. La liste est utilisée pour la collecte d'éléments avec des doublons.
3. De nouvelles méthodes sont définies dans l'interface List.

Ensemble

1. Est un regroupement non ordonné d'éléments.
2. Set est utilisé pour collecter des éléments sans doublons.
3. Aucune nouvelle méthode n'est définie dans l'interface Set, nous devons donc utiliser les méthodes d'interface Collection uniquement avec les sous-classes Set.

Liste:

Lists autorisent généralement les objets en double. Lists doivent être commandés, et sont donc accessibles par index.

Cours de mise en œuvre: ArrayList, LinkedList,Vector

Ensemble:

Sets ne permettent pas les objets en double. La plupart des implémentations ne sont pas ordonnées, mais elles sont spécifiques à l'implémentation.

Les classes d'implémentation incluent: HashSet(non ordonnées), LinkedHashSet(ordonnées), TreeSet(ordonnées par ordre naturel ou par comparateur fourni)

Comme nous parlons des interfaces Java, pourquoi ne pas regarder le Javadoc?!

• A Listest une collection ordonnée (séquence), qui permet généralement des doublons
• Une Setcollection a is ne contenant aucun élément en double, l'ordre d'itération peut être garanti par l'implémentation

Il n'y a AUCUNE mention de manque d'ordre concernant les Sets: cela dépend de l'implémentation.

Ce n'est peut-être pas la réponse que vous cherchez, mais le JavaDoc des classes de collections est en fait assez descriptif. Copier / coller:

Une collection ordonnée (également connue sous le nom de séquence). L'utilisateur de cette interface a un contrôle précis sur l'endroit où dans la liste chaque élément est inséré. L'utilisateur peut accéder aux éléments par leur index entier (position dans la liste), et rechercher des éléments dans la liste.

Contrairement aux ensembles, les listes autorisent généralement les éléments en double. Plus formellement, les listes autorisent généralement des paires d'éléments e1 et e2 telles que e1.equals (e2), et elles autorisent généralement plusieurs éléments nuls si elles autorisent des éléments nuls. Il n'est pas inconcevable que quelqu'un souhaite implémenter une liste qui interdit les doublons, en lançant des exceptions d'exécution lorsque l'utilisateur tente de les insérer, mais nous nous attendons à ce que cette utilisation soit rare.

Un ensemble est un groupe non ordonné d'objets distincts - aucun objet en double n'est autorisé. Il est généralement implémenté à l'aide du code de hachage des objets insérés. (Des implémentations spécifiques peuvent ajouter un ordre, mais pas l'interface elle-même.)

Une liste est un groupe ordonné d'objets qui peut contenir des doublons. Il pourrait être mis en œuvre avec un ArrayList, LinkedListetc.

Liste: la
liste autorise les éléments en double et les valeurs nulles. Facile à rechercher en utilisant l'index correspondant des éléments et il affichera également les éléments dans l'ordre d'insertion. Exemple: (liste liée)

import java.util.*;

public class ListExample {

 public static void main(String[] args) {
    // TODO Auto-generated method stub

    List<Integer> l=new LinkedList<Integer>();
    l.add(001);
    l.add(555);
    l.add(333);
    l.add(888);
    l.add(555);
    l.add(null);
    l.add(null);

    Iterator<Integer> il=l.iterator();

    System.out.println(l.get(0));

    while(il.hasNext()){
        System.out.println(il.next());
    }

    for(Integer str : l){
        System.out.println("Value:"+str);
    }
 }

}

Production:

1
1
555
333
888
555
null
null
Valeur: 1
Valeur: 555
Valeur: 333
Valeur: 888
Valeur: 555
Valeur: null
Valeur: null

Set:
Set n'autorise aucun élément en double et autorise une valeur nulle unique. Il ne conservera aucun ordre pour afficher les éléments. Seul TreeSetsera affiché dans l'ordre croissant.

Exemple: (TreeSet)

import java.util.TreeSet;

public class SetExample {

 public static void main(String[] args) {
    // TODO Auto-generated method stub

    TreeSet<String> set = new TreeSet<String>();
    try {
        set.add("hello");
        set.add("world");
        set.add("welcome");
        set.add("all");

        for (String num : set) {
            System.out.println( num);

        }
        set.add(null);
    } catch (NullPointerException e) {
        System.out.println(e);
        System.out.println("Set doesn't allow null value and duplicate value");
    }

 }

}

Production:

Bonjour tout le monde
Bienvenue java.lang.NullPointerException Set ne permet pas la valeur nulle et la valeur en double

1.La liste autorise les valeurs en double et l'ensemble ne permet pas les doublons

2.List conserve l'ordre dans lequel vous avez inséré des éléments dans la liste Set ne maintient pas l'ordre. 3.List est une séquence ordonnée d'éléments tandis que Set est une liste distincte d'éléments qui n'est pas ordonnée.

List Vs Set

1) L'ensemble ne permet pas les doublons. La liste permet la duplication. Basé sur l'implémentation de Set, il conserve également l'ordre d'insertion.

par exemple: LinkedHashSet. Il maintient l'ordre d'insertion.Veuillez vous référer, cliquez ici

2) contient la méthode. Par nature de l'ensemble, il donnera de meilleures performances d'accès. Meilleur cas, c'est o (1). Mais List a un problème de performances à invoquer contains.

Toutes les Listclasses conservent l'ordre d'insertion. Ils utilisent différentes implémentations basées sur les performances et d'autres caractéristiques (par exemple ArrayListpour la vitesse d'accès d'un index spécifique, LinkedListpour simplement maintenir l'ordre). Puisqu'il n'y a pas de clé, les doublons sont autorisés.

Les Setclasses ne conservent pas l'ordre d'insertion. Ils peuvent éventuellement imposer un ordre spécifique (comme avec SortedSet), mais ont généralement un ordre défini par l'implémentation basé sur une fonction de hachage (comme avec HashSet). Comme les Sets sont accessibles par clé, les doublons ne sont pas autorisés.

Commande ... une liste a une commande, pas un ensemble.

Peu de différences notables entre List et Set en Java sont données comme suit:

1) La différence fondamentale entre List et Set en Java autorise les éléments en double. List en Java autorise les doublons tandis que Set n'autorise aucun doublon. Si vous insérez un doublon dans Set, il remplacera l'ancienne valeur. Toute implémentation de Set in Java ne contiendra que des éléments uniques.

2) Une autre différence significative entre List et Set en Java est l'ordre. La liste est une collection ordonnée tandis que l'ensemble est une collection non ordonnée. La liste maintient l'ordre d'insertion des éléments, signifie que tout élément qui est inséré avant ira sur un index inférieur à tout élément qui est inséré après. Définir en Java ne maintient aucun ordre. Bien que Set fournisse une autre alternative appelée SortedSet qui peut stocker les éléments Set dans un ordre de tri spécifique défini par les méthodes Comparable et Comparator des objets stockés dans Set.

3) L'implémentation populaire de l'interface List en Java inclut ArrayList, Vector et LinkedList. Alors que l'implémentation populaire de l'interface Set comprend HashSet, TreeSet et LinkedHashSet.

Il est assez clair que si vous devez maintenir l'ordre d'insertion ou l'objet et que votre collection peut contenir des doublons, List est une solution. D'un autre côté, si votre exigence est de maintenir une collection unique sans doublons, Set est la solution.

Liste:

1. Doublons autorisés.
2. Ordonné en regroupant les éléments (en d'autres termes, ayant un ordre défini, pas besoin de trier par ordre croissant)

Ensemble:

1. Pas de doublons autorisés.
2. Non ordonné en regroupant les éléments (en d'autres termes, n'ayant pas d'ordre défini, il peut ou non être classé par ordre croissant)

Set<E>et List<E>sont tous deux utilisés pour stocker des éléments de type E. La différence est qu'il Setest stocké de manière non ordonnée et ne permet pas de valeurs en double. Listest utilisé pour stocker des éléments de manière ordonnée et permet des valeurs en double.

Setles éléments ne sont pas accessibles par une position d'index et les Listéléments sont accessibles par une position d'index.

Salut Tant de réponses sont déjà données .. Permettez-moi de souligner quelques points qui ne sont pas mentionnés jusqu'à présent:

• La plupart des implémentations de List (ArrayList, Vector) implémentent uneRandomAccess interface qui est une interface marqueur pour un accès plus rapide. Aucune des implémentations Set ne fait cela.
• La liste utilise un itérateur spécial appelé ListIterator qui prend en charge l'itération dans les deux sens . L'ensemble utilise Iterator qui ne prend en charge que l'itération à 1 sens
• HashSet prend 5,5 fois plus de mémoire qu'ArrayList pour stocker le même nombre d'éléments.

Le plus grand différent est le concept de base.

Depuis l' interface Set and List . L'ensemble est un concept mathématique. La méthode Set étend la collection, mais n'ajoute pas de nouvelle méthode. size () signifie cardinalité (plus est BitSet.cardinality, compteur linéaire Log Journal Log ， HyperLogLog ). addAll () signifie union. retenueAll () signifie intersection. removeAll () signifie différence.

Cependant, indiquez le manque de ces concepts. La liste ajoute beaucoup de méthode pour prendre en charge le concept de séquence que l' interface de collection ne fournit pas. le concept de base est INDEX . comme add (index, element), get (index), search (indexOf ()), remove (index) element. Liste fournir également « Voir Collection » de subList . L'ensemble n'a pas de vue. n'ont pas d'accès positionnel. La liste fournit également de nombreux algorithmes dans la classe Collections . sort (List), binarySearch (List), reverse (List), shuffle (List), fill (List). la méthode params est l' interface List . les éléments en double ne sont que le résultat de concepts. pas la différence essentielle.

La différence essentielle est donc le concept. L'ensemble est le concept de jeu de mathématiques. La liste est un concept de séquence.

Voici un exemple clair avec groovy. je crée un ensemble et une liste. alors j'essaye de stocker 20 valeurs générées aléatoirement dans chaque liste. la valeur générée peut être comprise entre 0 et 5

s = [] as Set
l = []

max = 5
print "random Numbers :"
20.times{
e = (int)Math.random()*max
s << e
l << e
print "$e, "
}


println "\n"
println "Set : $s "
println "list : $l

Le résultat :

nombres aléatoires: 4, 1, 4, 0, 1, 2, 4, 0, 0, 3, 4, 3, 2, 0, 4, 0, 1, 3, 1, 3

Ensemble : [4, 1, 0, 2, 3]

liste : [4, 1, 4, 0, 1, 2, 4, 0, 0, 3, 4, 3, 2, 0, 4, 0, 1, 3, 1, 3]

Vous pouvez voir que la différence est que:

• L'ensemble n'autorise pas les valeurs en double.
• La liste autorise les valeurs en double.

Comme la réponse, SET n'a pas de valeur en double et List peut. Bien sûr, l'ordre est une autre chose pour les différencier.

Ensemble: un ensemble ne peut pas contenir d'éléments en double dans ses collections. c'est aussi une collection non ordonnée. Pour accéder aux données de Set, il est nécessaire d'utiliser uniquement Iterator et la récupération basée sur l'index n'est pas possible pour cela. Il est principalement utilisé chaque fois que la collecte d'unicité requise.

Liste: Une liste peut avoir des éléments en double, avec le naturel ordonné lors de son insertion. Ainsi, il peut être récupéré des données basées sur un index ou un itérateur. Il est largement utilisé pour stocker la collection qui doit accéder en fonction de l'index.

Nom du sujet: List VS Set

Je viens de parcourir le sujet le plus important de Java appelé Collections Framework. J'ai pensé partager avec vous ma petite connaissance des collections. List, Set, Map en sont le sujet le plus important. Commençons donc par List et Set.

Différence entre la liste et l'ensemble:

1. List est une classe de collection qui étend la AbstractListclasse alors que Set est une classe de collection qui étend la AbstractSetclasse mais les deux implémentent l'interface Collection.

2. L'interface de liste autorise les valeurs en double (éléments) tandis que l'interface de définition n'autorise pas les valeurs en double. En cas d'éléments en double dans Set, il remplace les anciennes valeurs.

3. L'interface de liste autorise les valeurs NULL alors que l'interface Set n'autorise pas les valeurs Null. En cas d'utilisation de valeurs nulles dans Set, cela donne NullPointerException.

4. L'interface de liste maintient l'ordre d'insertion. Cela signifie que la façon dont nous ajoutons les éléments dans la liste de la même manière que nous l'obtenons en utilisant l'itérateur ou pour chaque style. Alors que les Setimplémentations ne maintiennent pas nécessairement l'ordre d'insertion. (Bien SortedSetqu'il utilise TreeSetet LinkedHashSetconserve l'ordre d'insertion).

5. L'interface de liste a ses propres méthodes définies tandis que l'interface Set n'a pas sa propre méthode, donc Set utilise uniquement les méthodes d'interface Collection.

6. L'interface de liste a une classe héritée appelée Vectortandis que l'interface Set n'a pas de classe héritée

7. Dernier point mais non le moindre ... La listIterator()méthode ne peut être utilisée que pour parcourir les éléments dans les classes de liste alors que nous pouvons utiliser la méthode iterator () pour accéder aux éléments de la classe Set

Pouvons-nous ajouter autre chose? S'il vous plaît, faites-moi savoir.

Merci.

Ensemble:

Ne peut pas avoir de valeurs en double L'ordre dépend de l'implémentation. Par défaut, il n'est pas commandé Impossible d'accéder par index

Liste:

Peut avoir des valeurs en double Ordonné par défaut Peut avoir accès par index