web-dev-qa-db-fra.com

Méthode la plus simple pour convertir une liste en un ensemble dans Java

Quel est le moyen le plus simple de convertir une List en Set en Java?

javacollections
588
OHHAI
Set<Foo> foo = new HashSet<Foo>(myList);
1012
sepp2k

Je suis d'accord avec sepp2k, mais il y a d'autres détails qui pourraient avoir de l'importance:

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 de la méthode .equals () sur vos objets. Ceci est fait en combinaison avec la méthode .hashCode (). (Pour plus sur l'égalité regarder ici )

Une alternative qui donne un ensemble trié est:

new TreeSet<Foo>(myList);

Cela fonctionne si Foo implémente Comparable. 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 de compareTo () (de l'interface comparable) ou de compare () (du comparateur) pour assurer l'unicité. Donc, si vous vous souciez de l'unicité, utilisez le HashSet. Si vous avez fini de trier, pensez au TreeSet. (Rappelez-vous: optimisez plus tard!) Si la gestion du temps compte, utilisez un HashSet, utilisez TreeSet. Notez que des implémentations plus efficaces de Set et de Map sont disponibles via Trove (et d’autres emplacements).

137
Spina

Si vous utilisez la bibliothèque Guava :

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

ou mieux:

Set<Foo> set = ImmutableSet.copyOf(list);
67
Vitalii Fedorenko

En utilisant Java 8, vous pouvez utiliser le flux:

List<Integer> mylist = Arrays.asList(100, 101, 102);
Set<Integer> myset = mylist.stream().collect(Collectors.toSet()));
24
JimB
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);
        }
    }
}
17
Sandeep Bhardwaj

Je voudrais effectuer une vérification Null avant de convertir à définir.

if(myList != null){
Set<Foo> foo = new HashSet<Foo>(myList);
}
8
ashish

Pour Java 8, c'est très simple:

List < UserEntity > vList= new ArrayList<>(); 
vList= service(...);
Set<UserEntity> vSet= vList.stream().collect(Collectors.toSet());
6
BERGUIGA Mohamed Amine

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

N'oublions pas notre ami relativement nouveau, Java-8 API. Si vous devez prétraiter une liste avant de la convertir en jeu, il est préférable d’avoir quelque chose comme:

list.stream().<here goes some preprocessing>.collect(Collectors.toSet());
5
shabunc

Avec Java 10, vous pouvez maintenant utiliser Set#copyOf pour convertir facilement un _List<E>_ en un non modifiable _Set<E>_:

Exemple:

_var set = Set.copyOf(list);
_

Gardez à l'esprit qu'il s'agit d'une opération non ordonnée et que les éléments null ne sont pas , car ils jetteront un NullPointerException.

Si vous souhaitez qu'il soit modifiable, transmettez-le simplement au constructeur d'une implémentation Set.

3
Jacob G.

Il y a différentes façons d'obtenir une 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);

Lorsque nous utilisons Collectors.toSet(), il renvoie un ensemble et conformément à la 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 (vérifiez set3).

3
i_am_zero

Java - addAll

set.addAll(aList);

Java - nouvel objet

new HashSet(list)

Java-8

list.stream().collect(Collectors.toSet());

en utilisant Guva

 Sets.newHashSet(list)

Apache Commons

CollectionUtils.addAll(targetSet, sourceList);
3
Ramesh Papaganti

La meilleure façon d'utiliser constructeur

Set s= new HashSet(list);

Dans Java 8, vous pouvez également utiliser stream api ::

Set s= list.stream().collect(Collectors.toSet());
2
Nirbhay Rana

Une solution plus Java 8 résiliente avec Optional.ofNullable

Set<Foo> mySet = Optional.ofNullable(myList).map(HashSet::new).orElse(null);
2
Shenal Silva

Si vous utilisez Eclipse Collections :

MutableSet<Integer> mSet = Lists.mutable.with(1, 2, 3).toSet();
MutableIntSet mIntSet = IntLists.mutable.with(1, 2, 3).toSet();

L'interface MutableSet étend Java.util.Set alors que l'interface MutableIntSet ne le fait pas. Vous pouvez également convertir n'importe quel Iterable en Set à l'aide de la classe de fabrique Sets.

Set<Integer> set = Sets.mutable.withAll(List.of(1, 2, 3));

Il y a plus d'explications sur les usines mutables disponibles dans Eclipse Collections ici .

Si vous voulez un ImmutableSet d'un List, vous pouvez utiliser la fabrique Sets comme suit:

ImmutableSet<Integer> immutableSet = Sets.immutable.withAll(List.of(1, 2, 3))

Remarque: je suis un partisan des collections Eclipse

1
Donald Raab