Quelle est la différence entre Set et List?

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

Listes ordonnées d'éléments (uniques ou non)
se conformer à L'interface de Java nommée List
Peut être consulté par index

Implémenté en utilisant

• LinkedList
• ArrayList

Listes d'éléments uniques:
Conforme à Java de l'interface nommée Set
not peut-on Accéder à l'index

Implémenté en utilisant

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

Les deux interfaces Set et List sont conformes à L'interface de Java nommée Collection

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'éléments
• Un ensemble est un regroupement non ordonné d'éléments 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 n'autorise pas les doublons est un ensemble.

Liste

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

Ensemble

1. est un regroupement non ordonné d'éléments.
2. Set est utilisé pour la collection d'éléments sans doublons.
3. Aucune nouvelle méthode n'est définie dans L'interface Set, Nous devons donc utiliser des méthodes D'interface de Collection uniquement avec des sous-classes Set.

Liste:

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

Les classes D'implémentation incluent: ArrayList, LinkedList, Vector

Ensemble:

Sets do pas permettent de dupliquer des objets. 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é), LinkedHashSet (ordonné), TreeSet (commandé par ordre naturel ou fourni comparateur)

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

• a List est une collection ordonnée (séquence), qui permet généralement doublons
• a {[1] } A est une collection qui ne contient pas d'éléments en double, d'itération l'ordre peut être garanti par la mise en œuvre

Il N'y a aucune mention sur le manque d'ordre concernant les ensembles: cela dépend de l'implémentation.

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

Une collection ordonnée (également appelée séquence). L'utilisateur de cette interface a un contrôle précis sur où dans le liste chaque élément est inséré. Le 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 permettent généralement dupliquer élément. Plus formellement, les listes autorisent généralement des paires de éléments e1 et e2 tels que e1.est égal à(e2), et ils autoriser plusieurs éléments null s'ils autoriser les éléments null du tout. Il n'est pas inconcevable que quelqu'un pourrait souhaiter pour mettre en œuvre une liste qui interdit doublons, en lançant runtime exceptions lorsque l'utilisateur tente de insérez-les, mais nous nous attendons à cette utilisation pour être rares.

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

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

1.List autorise les valeurs en double et set n'autorise pas les doublons

2.Liste maintient 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 alors que Set est une liste distincte d'éléments qui n'est pas ordonnée.

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

Les classes Set ne maintiennent 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). Étant donné que Sets sont accessibles par clé, les doublons ne sont pas autorisés.

Liste Vs

1) Set n'autorise pas les doublons. Liste permet dupliquer. Basé sur L'implémentation de Set, il maintient é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 une meilleure performance à l'accès. Dans le meilleur des cas son o(1). Mais List a un problème de performance à invoquer contains.

Liste:
Liste permet de dupliquer les éléments et les valeurs null. Facile à rechercher en utilisant l'index correspondant des éléments et aussi il affichera les éléments dans l'ordre d'insertion. Exemple: (linkedlist)

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);
    }
 }

}

Sortie:

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

Ensemble:
Set n'autorise aucun doublon éléments et il permettent null unique value.It ne conservera aucun ordre pour afficher les éléments.Seul TreeSet s'affiche 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");
    }

 }

}

Sortie:

Tous
bonjour
bienvenue
monde
Java.lang.NullPointerException
Set n'autorise pas la valeur null et la valeur dupliquée

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

Quelques 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 permet de dupliquer des éléments. 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 En Java ne contiendra que des éléments uniques.

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

3) mise en œuvre populaire de la liste interface en Java comprend 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 avez besoin de 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 le chemin à parcourir.

Liste:

1. doublons autorisés.
2. ordonné dans les éléments de regroupement.(En d'autres termes ayant défini order.No besoin de trier par ordre croissant)

Ensemble:

1. pas permis doublons.
2. Unordered dans les éléments de regroupement.(En d'autres termes n'ayant pas défini order.It peut ou ne peut pas être organisé dans l'ordre croissant)

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

Set les éléments ne sont pas accessibles par un index de position, et List éléments peuvent être accessibles avec une position d'index.

La Duplicité

L'ensemble ne fonctionne pas autoriser les doublons. Ensemble et toutes les classes qui implémente l'interface Set doit avoir des éléments uniques. La liste permet de dupliquer les éléments. N'importe quel nombre d'éléments en double peut être inséré dans la liste sans affecter les mêmes valeurs existantes et leur index.

Valeurs nulles

List allows any number of null values.
Set allows single null value at most

Commande

Liste et toutes ses classes d'implémentation ordre d'insertion. Set ne conserve aucun ordre encore peu de ses classes trient les éléments dans un ordre tel que LinkedHashSet maintient les éléments dans l'ordre d'insertion et TreeSet (les éléments conservent l'ordre croissant Par défaut)

Les implémentations de la Classe

List: ArrayList, LinkedList 
Set: HashSet, LinkedHashSet, TreeSet 

Différence basée sur les points suivants

1) duplicité: liste permet des éléments en double. N'importe quel nombre d'éléments en double peut être inséré dans la liste sans affecter les mêmes valeurs existantes et leurs index. Set n'autorise pas les doublons. Set et toutes les classes qui implémentent Set interface doivent avoir des éléments uniques.

2) valeurs Null: List permet un nombre quelconque de valeurs null. Set permet une seule valeur nulle au maximum.

3) Ordre: liste et tous ses les classes d'implémentation maintiennent l'ordre d'insertion. Set ne maintient aucun ordre; encore peu de ses classes trient les éléments dans un ordre tel que LinkedHashSet maintient les éléments dans l'ordre d'insertion.

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

• la plupart des implémentations de liste (ArrayList,Vector) implémentent RandomAccess interface qui est une interface de marqueur pour un accès plus rapide. Aucune des implémentations de liste ne le fait.
• List utilise un itérateur spécial appelé ListIterator qui supporte l'itération dans les deux sens . Set utilise Iterator qui ne prend en charge que l'itération à 1 sens
• HashSet prend 5.5 fois plus de mémoire {[7] } que ArrayList pour le stockage même nombre d'éléments.

Voici un exemple clair avec groovy. je crée un ensemble et une liste. ensuite, j'essaie de stocker 20 valeur générée 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 :

De 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:

• Set n'autorise pas les valeurs en double.
• liste autoriser les valeurs en double.

Comme la réponse comme définie n'a pas de valeur en double et la liste peut. Bien sûr, l'ordre est une autre chose à les différents à part.

Ensemble: Un ensemble ne peut pas avoir 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 Iterator uniquement et la récupération basée sur l'index n'est pas possible pour cela. Il est principalement utilisé chaque fois que nécessaire collection unicité.

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

Nom du sujet: liste VS Ensemble

Je viens de passer par le sujet le plus important de Java appelé Collections Framework. J'ai pensé partager mes connaissances sur les Collections avec vous. Liste, Ensemble, carte sont le sujet le plus important de celui-ci. Commençons donc par List and Set.

Différence entre la liste et L'Ensemble:

1. List est une classe de collection qui étend la classe AbstractList Où as Set est une classe de collection qui étend la classe AbstractSet mais les deux implémente la Collection interface.

2. L'interface List permet des valeurs en double (éléments) tandis que L'Interface Set n'autorise pas les valeurs en double. Dans le cas d'éléments dupliqués dans Set, il remplace les anciennes valeurs.

3. L'interface de liste permet des valeurs NULL où as Set interface n'autorise pas les valeurs Null. En cas d'utilisation de valeurs Null dans Set, il 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 obtenez-le en utilisant iterator ou pour chaque style. Alors que les implémentations Set ne maintiennent pas nécessairement l'ordre d'insertion. (Bien que {[4] } utilise TreeSet et que LinkedHashSet conserve l'ordre d'insertion).

5. List interface a ses propres méthodes définies alors que Set interface n'a pas sa propre méthode donc Set utilise uniquement des méthodes D'interface de Collection.

6. List interface a une classe héritée appelée Vector alors que Set interface n'a aucun héritage classe

7. Dernier point mais non le moins... La méthode listIterator() ne peut être utilisée que pour faire défiler les éléments dans les Classes List alors que nous pouvons utiliser la méthode iterator() pour accéder aux éléments de classe Set

Autre chose peut-on ajouter? S'il vous plaît laissez-moi savoir.

Merci.

Ensemble:

Ne peut pas avoir de valeurs en double La commande dépend de la mise en œuvre. Par défaut, il n'est pas commandé Impossible d'avoir accès par index

Liste:

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