Najprostszym sposobem na konwersję listy do zestawu w Javie

Jaki jest najłatwiejszy sposób przekonwertowania pliku ListA Setna język Java?

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

Zgadzam się z sepp2k, ale istnieją inne szczegóły, które mogą mieć znaczenie:

new HashSet<Foo>(myList);

da ci nieposortowany zestaw, który nie ma duplikatów. W takim przypadku duplikacja jest identyfikowana za pomocą metody .equals () na twoich obiektach. Odbywa się to w połączeniu z metodą .hashCode (). (Aby uzyskać więcej informacji na temat równości, patrz tutaj )

Alternatywą, która daje posortowany zestaw, jest:

new TreeSet<Foo>(myList);

Działa to, jeśli Foo implementuje porównywalne. Jeśli tak nie jest, możesz użyć komparatora:

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

Zależy to od funkcji CompareTo () (z porównywalnego interfejsu) lub Compare () (z komparatora), aby zapewnić unikalność. Jeśli więc zależy Ci na wyjątkowości, skorzystaj z zestawu HashSet. Jeśli chcesz posortować, rozważ zestaw TreeSet. (Pamiętaj: zoptymalizuj później!) Jeśli liczy się efektywność czasu, użyj HashSet, jeśli liczy się wydajność przestrzeni, spójrz na TreeSet. Zauważ, że bardziej wydajne wdrożenia Set i Map są dostępne za pośrednictwem Trove (i innych lokalizacji).

Jeśli korzystasz z biblioteki Guava :

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

albo lepiej:

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

Za pomocą java 8 możesz korzystać ze strumienia:

List<Integer> mylist = Arrays.asList(100, 101, 102);
Set<Integer> myset = mylist.stream().collect(Collectors.toSet()));

Set<E> alphaSet  = new HashSet<E>(<your List>);

lub pełny przykład

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

Wykonałbym sprawdzanie wartości Null przed konwersją na set.

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

Możesz przekonwertować List<>naSet<>

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

W przypadku Java 8 jest to bardzo łatwe:

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

Java - addAll

set.addAll(aList);

Java - nowy obiekt

new HashSet(list)

Java-8

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

Korzystanie z Guva

 Sets.newHashSet(list)

Apache Commons

CollectionUtils.addAll(targetSet, sourceList);

Java 10

var set = Set.copyOf(list);

Nie zapominajmy o naszym stosunkowo nowym przyjacielu, java-8Stream API. Jeśli musisz wstępnie przetworzyć listę przed przekonwertowaniem jej na zestaw, lepiej mieć coś takiego:

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

Najlepszy sposób na użycie konstruktora

Set s= new HashSet(list);

W java 8 możesz również używać interfejsu API streamu:

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

Istnieją różne sposoby uzyskania Setjako:

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

Gdy używamy Collectors.toSet()zwraca zestaw i zgodnie doc: There are no guarantees on the type, mutability, serializability, or thread-safety of the Set returned. Jeśli chcemy uzyskać zestaw HashSet, możemy użyć innej alternatywy, aby uzyskać zestaw (sprawdź set3).

W Javie 10 możesz teraz Set#copyOfłatwo przekonwertować plik List<E>na niemodyfikowalny Set<E>:

Przykład:

var set = Set.copyOf(list);

Należy pamiętać, że jest to operacja nieuporządkowana, a nullelementy nie są dozwolone, ponieważ spowoduje to rzut NullPointerException.

Jeśli chcesz, aby można go było modyfikować, po prostu przekaż go konstruktorowi Setimplementacji.

Bardziej odporne rozwiązanie Java 8 z Optional.ofNullable

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

Jeśli korzystasz z kolekcji Eclipse :

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

MutableSetInterfejs rozszerza java.util.Setnatomiast MutableIntSetinterfejs nie. Można również przekonwertować dowolny IterableDo Setkorzystania z Setsklasy fabrycznej.

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

Więcej wyjaśnień dotyczących modyfikowalnych fabryk dostępnych jest w Eclipse Collections tutaj .

Jeśli chcesz ImmutableSetod List, możesz użyć Setsfabryki w następujący sposób:

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

Uwaga: jestem osobą odpowiedzialną za kolekcje Eclipse

Pamiętaj, że konwersja z listy do zestawu usunie duplikaty z kolekcji, ponieważ lista obsługuje duplikaty, ale zestaw nie obsługuje duplikatów w Javie.

Bezpośrednia konwersja: najczęstszy i najprostszy sposób konwersji listy na zestaw

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

Kolekcje Apache Commons: możesz także użyć interfejsu API Commons Commons do konwersji listy na zestaw: -

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

Korzystanie ze strumienia: Innym sposobem jest konwersja podanej listy do strumienia, a następnie strumieniowanie w celu ustawienia: -

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