La façon la plus facile de convertir une liste en un ensemble en Java

Quelle est la meilleure façon de convertir un List en un Set en Java?

520
demandé sur Rodrigue 2009-09-16 02:02:35

13 réponses

Set<Foo> foo = new HashSet<Foo>(myList);
894
répondu sepp2k 2015-07-13 18:11:14

je suis d'accord avec sepp2k, mais il ya quelques autres détails qui comptent:

new HashSet<Foo>(myList);

vous donnera un ensemble non trié qui n'a pas de doublons. Dans ce cas, la duplication est identifiée à l'aide du .la méthode equals () sur vos objets. Cela se fait en combinaison avec le .hashCode() de la méthode. (Pour plus d'informations sur l'égalité, voir ici )

une alternative qui donne un ensemble trié est:

new TreeSet<Foo>(myList);

cela fonctionne si Foo met en œuvre comparables. Si ce n'est pas le cas, vous pouvez utiliser un comparateur:

Set<Foo> lSet = new TreeSet<Foo>(someComparator);
lSet.addAll(myList);

cela dépend soit de compareTo() (de l'interface comparable) ou de compare() (du comparateur) pour assurer l'unicité. Donc, si vous vous souciez juste de l'unicité, utilisez le HashSet. Si vous êtes après le tri, pensez à la toile D'arbre. (Rappelez-vous: Optimiser plus tard!) Si l'efficacité dans le temps est importante utilisez un HashSet si l'efficacité dans l'espace est importante, regardez TreeSet. Notez que des implémentations plus efficaces de Set et Map sont disponibles via Trove (et d'autres sites).

122
répondu Spina 2017-05-23 12:18:15

si vous utilisez le Guava bibliothèque:

Set<Foo> set = Sets.newHashSet(list);

ou, mieux:

Set<Foo> set = ImmutableSet.copyOf(list);
63
répondu Vitalii Fedorenko 2012-07-20 12:03:34

en utilisant java 8 Vous pouvez utiliser stream:

List<Integer> mylist = Arrays.asList(100, 101, 102);
Set<Integer> myset = mylist.stream().collect(Collectors.toSet()));
19
répondu JimB 2015-04-13 15:53:54
Set<E> alphaSet  = new HashSet<E>(<your List>);

ou exemple complet

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

public class ListToSet
{
    public static void main(String[] args)
    {
        List<String> alphaList = new ArrayList<String>();
        alphaList.add("A");
        alphaList.add("B");
        alphaList.add("C");
        alphaList.add("A");
        alphaList.add("B");
        System.out.println("List values .....");
        for (String alpha : alphaList)
        {
            System.out.println(alpha);
        }
        Set<String> alphaSet = new HashSet<String>(alphaList);
        System.out.println("\nSet values .....");
        for (String alpha : alphaSet)
        {
            System.out.println(alpha);
        }
    }
}
14
répondu Sandeep Bhardwaj 2015-08-03 07:52:04

j'effectuerais une vérification nulle avant de convertir en set.

if(myList != null){
Set<Foo> foo = new HashSet<Foo>(myList);
}
9
répondu ashish 2014-05-13 14:51:41

vous pouvez convertir List<> en Set<>

Set<T> set=new HashSet<T>();

//Added dependency -> If list is null then it will throw NullPointerExcetion.

Set<T> set;
if(list != null){
    set = new HashSet<T>(list);
}
5
répondu savanibharat 2016-01-19 15:47:12

n'oublions pas notre ami relativement nouveau, stream API. Si vous avez besoin de préprocéder à la liste avant de la convertir en un ensemble, il est préférable d'avoir quelque chose comme:

list.stream().<here goes some preprocessing>.collect(Collectors.toSet());
5
répondu shabunc 2017-05-30 12:50:07

pour Java 8 c'est très facile:

List < UserEntity > vList= new ArrayList<>(); 
vList= service(...);
Set<UserEntity> vSet= vList.stream().collect(Collectors.toSet());
4
répondu BERGUIGA Mohamed Amine 2018-07-23 09:09:13

il y a plusieurs façons d'obtenir un Set comme:

    List<Integer> sourceList = new ArrayList();
    sourceList.add(1);
    sourceList.add(2);
    sourceList.add(3);
    sourceList.add(4);

    // Using Core Java
    Set<Integer> set1 = new HashSet<>(sourceList);  //needs null-check if sourceList can be null.

    // Java 8
    Set<Integer> set2 = sourceList.stream().collect(Collectors.toSet());
    Set<Integer> set3 = sourceList.stream().collect(Collectors.toCollection(HashSet::new));

    //Guava
    Set<Integer> set4 = Sets.newHashSet(sourceList);

    // Apache commons
    Set<Integer> set5 = new HashSet<>(4);
    CollectionUtils.addAll(set5, sourceList);

quand nous utilisons Collectors.toSet() il renvoie un ensemble et selon le doc: There are no guarantees on the type, mutability, serializability, or thread-safety of the Set returned . Si nous voulons obtenir un HashSet alors nous pouvons utiliser l'autre alternative pour obtenir un ensemble (cochez set3 ).

2
répondu i_am_zero 2016-05-23 07:54:18

plus Java 8 solution de résilience avec Optional.ofNullable

Set<Foo> mySet = Optional.ofNullable(myList).map(HashSet::new).orElse(null);
2
répondu Shenal Silva 2018-01-20 16:00:28

avec Java 10, vous pouvez maintenant utiliser Set#copyOf pour convertir facilement un List<E> en un unmodifiable Set<E> :

exemple:

var set = Set.copyOf(list);

gardez à l'esprit qu'il s'agit d'une opération non ordonnée, et null éléments sont Non permis, car il lancera un NullPointerException .

si vous souhaitez qu'il soit modifiable, passez-le simplement dans le constructeur un Set la mise en œuvre.

2
répondu Jacob G. 2018-03-01 20:24:07

la meilleure façon d'utiliser le constructeur

Set s= new HashSet(list);

en java 8, Vous pouvez également utiliser l'api stream::

Set s= list.stream().collect(Collectors.toSet());
0
répondu Nirbhay Rana 2018-09-18 09:40:09