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?
13 réponses
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).
si vous utilisez le Guava bibliothèque:
Set<Foo> set = Sets.newHashSet(list);
ou, mieux:
Set<Foo> set = ImmutableSet.copyOf(list);
en utilisant java 8 Vous pouvez utiliser stream:
List<Integer> mylist = Arrays.asList(100, 101, 102);
Set<Integer> myset = mylist.stream().collect(Collectors.toSet()));
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);
}
}
}
j'effectuerais une vérification nulle avant de convertir en set.
if(myList != null){
Set<Foo> foo = new HashSet<Foo>(myList);
}
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);
}
n'oublions pas notre ami relativement nouveau, java-8 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());
pour Java 8 c'est très facile:
List < UserEntity > vList= new ArrayList<>();
vList= service(...);
Set<UserEntity> vSet= vList.stream().collect(Collectors.toSet());
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
).
plus Java 8 solution de résilience avec Optional.ofNullable
Set<Foo> mySet = Optional.ofNullable(myList).map(HashSet::new).orElse(null);
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.
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());