A maneira mais fácil de converter uma lista em um conjunto em Java

Qual é a maneira mais fácil de converter um Listpara um Setem Java?

Set<Foo> foo = new HashSet<Foo>(myList);

Concordo com o sepp2k, mas existem outros detalhes que podem ser importantes:

new HashSet<Foo>(myList);

fornecerá um conjunto não classificado que não possui duplicatas. Nesse caso, a duplicação é identificada usando o método .equals () em seus objetos. Isso é feito em combinação com o método .hashCode (). (Para mais informações sobre igualdade, veja aqui )

Uma alternativa que fornece um conjunto classificado é:

new TreeSet<Foo>(myList);

Isso funciona se o Foo implementa Comparable. Caso contrário, convém usar um comparador:

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

Isso depende de compareTo () (da interface comparável) ou compare () (do comparador) para garantir a exclusividade. Portanto, se você se preocupa apenas com a exclusividade, use o HashSet. Se você estiver após a classificação, considere o TreeSet. (Lembre-se: otimizar mais tarde!) Se a eficiência do tempo interessar, use um HashSet se a eficiência do espaço importar, consulte o TreeSet. Observe que implementações mais eficientes de Set e Map estão disponíveis no Trove (e em outros locais).

Se você usa a biblioteca Guava :

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

ou melhor:

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

Usando o java 8, você pode usar o 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 exemplo completo

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

Eu faria uma verificação nula antes de converter para definir.

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

Você pode converter List<>paraSet<>

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

Para Java 8 é muito fácil:

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

Java - addAll

set.addAll(aList);

Java - novo Objeto

new HashSet(list)

Java-8

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

Usando o Guva

 Sets.newHashSet(list)

Apache Commons

CollectionUtils.addAll(targetSet, sourceList);

Java 10

var set = Set.copyOf(list);

Não vamos esquecer nosso amigo relativamente novo, java-8API de fluxo. Se você precisar pré-processar a lista antes de convertê-la em um conjunto, é melhor ter algo como:

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

A melhor maneira de usar o construtor

Set s= new HashSet(list);

No java 8, você também pode usar a API do stream:

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

Existem várias maneiras de obter um Setcomo:

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

Quando usamos Collectors.toSet()ele retorna um conjunto e de acordo com o doc: There are no guarantees on the type, mutability, serializability, or thread-safety of the Set returned. Se quisermos obter um HashSet, podemos usar a outra alternativa para obter um conjunto (verificação set3).

Com o Java 10, agora você pode usar Set#copyOfpara converter facilmente um List<E>em um não modificável Set<E>:

Exemplo:

var set = Set.copyOf(list);

Lembre-se de que esta é uma operação não ordenada e que nullelementos não são permitidos, pois isso gera a NullPointerException.

Se você deseja que seja modificável, basta passá-lo ao construtor uma Setimplementação.

Uma solução mais resistente ao Java 8 com Optional.ofNullable

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

Se você usar o Eclipse Collections :

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

A MutableSetinterface se estende java.util.Setenquanto a MutableIntSetinterface não. Você também pode converter qualquer Iterableum em Setusando a Setsclasse de fábrica.

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

Há mais explicações sobre as fábricas mutáveis ​​disponíveis nas Coleções Eclipse aqui .

Se você deseja um ImmutableSetde a List, pode usar a Setsfábrica da seguinte maneira:

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

Nota: Eu sou um confirmador das Coleções Eclipse

Lembre-se de que a conversão de Lista em Conjunto removerá duplicatas da coleção, pois a Lista suporta duplicatas, mas o Conjunto não suporta duplicatas em Java.

Conversão direta: a maneira mais comum e simples de converter uma lista em um conjunto

// Creating a list of strings
List<String> list = Arrays.asList("One", "Two", "Three", "Four");

// Converting a list to set
Set<String> set = new HashSet<>(list);

Coleções do Apache Commons: Você também pode usar a API do Commons Collections para converter uma lista em um conjunto: -

// Creating a list of strings
List<String> list = Arrays.asList("One", "Two", "Three", "Four");

// Creating a set with the same number of members in the list 
Set<String> set = new HashSet<>(4);

// Adds all of the elements in the list to the target set
CollectionUtils.addAll(set, list);

Usando Stream: Outra maneira é converter a lista fornecida em stream e depois transmitir para definir: -

// Creating a list of strings 
List<String> list = Arrays.asList("One", "Two", "Three", "Four"); 

// Converting to set using stream 
Set<String> set = list.stream().collect(Collectors.toSet());