La forma más fácil de convertir una lista en un conjunto en Java

¿Cuál es la forma más fácil de convertir Lista a Seten Java?

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

Estoy de acuerdo con sepp2k, pero hay otros detalles que pueden ser importantes:

new HashSet<Foo>(myList);

le dará un conjunto sin clasificar que no tiene duplicados. En este caso, la duplicación se identifica utilizando el método .equals () en sus objetos. Esto se realiza en combinación con el método .hashCode (). (Para más información sobre igualdad, mira aquí )

Una alternativa que da un conjunto ordenado es:

new TreeSet<Foo>(myList);

Esto funciona si Foo implementa Comparable. Si no es así, es posible que desee utilizar un comparador:

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

Esto depende de compareTo () (desde la interfaz comparable) o compare () (desde el comparador) para garantizar la unicidad. Entonces, si solo te importa la singularidad, usa el HashSet. Si buscas ordenar, considera el TreeSet. (Recuerde: ¡Optimice más tarde!) Si la eficiencia del tiempo es importante, use un HashSet si la eficiencia del espacio es importante, mire TreeSet. Tenga en cuenta que las implementaciones más eficientes de Set y Map están disponibles a través de Trove (y otras ubicaciones).

Si usa la biblioteca Guava :

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

o mejor:

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

Usando java 8 puedes usar 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>);

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

Realizaría una comprobación nula antes de convertir a set.

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

Puedes convertir List<>aSet<>

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 es muy fácil:

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

Java - addAll

set.addAll(aList);

Java - nuevo objeto

new HashSet(list)

Java-8

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

Usando Guva

 Sets.newHashSet(list)

Apache Commons

CollectionUtils.addAll(targetSet, sourceList);

Java 10

var set = Set.copyOf(list);

No olvidemos a nuestro amigo relativamente nuevo, java-8Stream API. Si necesita preprocesar la lista antes de convertirla en un conjunto, es mejor tener algo como:

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

La mejor manera de usar constructor

Set s= new HashSet(list);

En java 8 también puedes usar stream api ::

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

Hay varias formas de obtener un 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);

Cuando usamos Collectors.toSet()devuelve un conjunto y según el doc: There are no guarantees on the type, mutability, serializability, or thread-safety of the Set returned. Si queremos obtener un, HashSetentonces podemos usar la otra alternativa para obtener un conjunto (verificar set3).

Con Java 10, ahora puede usar Set#copyOfpara convertir fácilmente un List<E>a no modificable Set<E>:

Ejemplo:

var set = Set.copyOf(list);

Tenga en cuenta que esta es una operación desordenada, y los nullelementos no están permitidos, ya que arrojará un NullPointerException.

Si desea que sea modificable, simplemente páselo al constructor una Setimplementación.

Una solución más resistente de Java 8 con Optional.ofNullable

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

Si usa Eclipse Collections :

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

La MutableSetinterfaz se extiende java.util.Setmientras que la MutableIntSetinterfaz no. También puede convertir cualquiera Iterablea Setusar la Setsclase de fábrica.

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

Hay más explicaciones de las fábricas mutables disponibles en Eclipse Collections aquí .

Si desea un ImmutableSetde a List, puede usar la Setsfábrica de la siguiente manera:

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

Nota: Soy un committer para Eclipse Collections

Recuerde que, la conversión de List a Set eliminará los duplicados de la colección porque List admite duplicados pero Set no admite duplicados en Java.

Conversión directa: la forma más común y sencilla de convertir una lista en un 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);

Apache Commons Collections: también puede usar la API de Commons Collections para convertir una lista en un 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);

Uso de Stream: Otra forma es convertir la lista dada a stream, luego stream para establecer: -

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