Jak przekonwertować tablicę na zestaw w Javie

Chciałbym przekonwertować tablicę na zestaw w Javie. Istnieje kilka oczywistych sposobów na zrobienie tego (np. Za pomocą pętli), ale chciałbym coś bardziej schludnego, na przykład:

java.util.Arrays.asList(Object[] a);

Jakieś pomysły?

Lubię to:

Set<T> mySet = new HashSet<>(Arrays.asList(someArray));

W Javie 9+, jeśli niemodyfikowalny zestaw jest w porządku:

Set<T> mySet = Set.of(someArray);

W Javie 10+ parametr typu ogólnego można wywnioskować na podstawie typu komponentu tablic:

var mySet = Set.of(someArray);

Set<T> mySet = new HashSet<T>();
Collections.addAll(mySet, myArray);

To jest Collection.addAll (java.util.Collection, T ...) z JDK 6.

Dodatkowo: co jeśli nasza tablica jest pełna prymitywów?

Dla JDK <8 po prostu napisałbym oczywistą forpętlę, aby wykonać zawijanie i dodawanie do zestawu w jednym przebiegu.

Dla JDK> = 8 atrakcyjną opcją jest coś takiego:

Arrays.stream(intArray).boxed().collect(Collectors.toSet());

Z Guava możesz:

T[] array = ...
Set<T> set = Sets.newHashSet(array);

Java 8:

String[] strArray = {"eins", "zwei", "drei", "vier"};

Set<String> strSet = Arrays.stream(strArray).collect(Collectors.toSet());
System.out.println(strSet);
// [eins, vier, zwei, drei]

Varargs też będzie działać!

Stream.of(T... values).collect(Collectors.toSet());

Java 8

Mamy również opcję korzystania Stream. Możemy uzyskać strumień na różne sposoby:

Set<String> set = Stream.of("A", "B", "C", "D").collect(Collectors.toCollection(HashSet::new));
System.out.println(set);

String[] stringArray = {"A", "B", "C", "D"};
Set<String> strSet1 = Arrays.stream(stringArray).collect(Collectors.toSet());
System.out.println(strSet1);

// if you need HashSet then use below option.
Set<String> strSet2 = Arrays.stream(stringArray).collect(Collectors.toCollection(HashSet::new));
System.out.println(strSet2);

Kod źródłowy Collectors.toSet()pokazuje, że elementy są dodawane jeden po drugim, HashSetale specyfikacja nie gwarantuje, że będzie to HashSet.

„Nie ma żadnych gwarancji dotyczących rodzaju, zmienności, możliwości serializacji ani bezpieczeństwa wątków zwracanego zestawu”.

Lepiej więc użyć późniejszej opcji. Dane wyjściowe to: [A, B, C, D] [A, B, C, D] [A, B, C, D]

Niezmienny zestaw (Java 9)

Java 9 wprowadziła Set.ofstatyczną metodę fabryczną, która zwraca niezmienny zestaw dla dostarczonych elementów lub tablicy.

@SafeVarargs
static <E> Set<E> of​(E... elements)

Sprawdź szczegółowe informacje na temat niezmiennych metod statycznych .

Niezmienny zestaw (Java 10)

Możemy również uzyskać niezmienny zestaw na dwa sposoby:

1. Set.copyOf(Arrays.asList(array))
2. Arrays.stream(array).collect(Collectors.toUnmodifiableList());

Ta metoda Collectors.toUnmodifiableList()korzysta z metody wewnętrznej Set.ofwprowadzonej w Javie 9. Sprawdź także moją odpowiedź, aby uzyskać więcej.

Po zakończeniu możesz Arrays.asList(array)wykonaćSet set = new HashSet(list);

Oto przykładowa metoda, którą możesz napisać:

public <T> Set<T> GetSetFromArray(T[] array) {
    return new HashSet<T>(Arrays.asList(array));
}

W kolekcji Eclipse działają następujące elementy:

Set<Integer> set1 = Sets.mutable.of(1, 2, 3, 4, 5);
Set<Integer> set2 = Sets.mutable.of(new Integer[]{1, 2, 3, 4, 5});
MutableSet<Integer> mutableSet = Sets.mutable.of(1, 2, 3, 4, 5);
ImmutableSet<Integer> immutableSet = Sets.immutable.of(1, 2, 3, 4, 5);

Set<Integer> unmodifiableSet = Sets.mutable.of(1, 2, 3, 4, 5).asUnmodifiable();
Set<Integer> synchronizedSet = Sets.mutable.of(1, 2, 3, 4, 5).asSynchronized();
ImmutableSet<Integer> immutableSet = Sets.mutable.of(1, 2, 3, 4, 5).toImmutable();

Uwaga: jestem osobą odpowiedzialną za kolekcje Eclipse

Szybko: możesz:

// Fixed-size list
List list = Arrays.asList(array);

// Growable list
list = new LinkedList(Arrays.asList(array));

// Duplicate elements are discarded
Set set = new HashSet(Arrays.asList(array));

i odwrócić

// Create an array containing the elements in a list
Object[] objectArray = list.toArray();
MyClass[] array = (MyClass[])list.toArray(new MyClass[list.size()]);

// Create an array containing the elements in a set
objectArray = set.toArray();
array = (MyClass[])set.toArray(new MyClass[set.size()]);

Napisałem poniżej z powyższej porady - ukraść to ... to miłe!

/**
 * Handy conversion to set
 */
public class SetUtil {
    /**
     * Convert some items to a set
     * @param items items
     * @param <T> works on any type
     * @return a hash set of the input items
     */
    public static <T> Set<T> asSet(T ... items) {
        return Stream.of(items).collect(Collectors.toSet());
    }
}

Odnotowano wiele wspaniałych odpowiedzi już, ale większość z nich nie będzie działać z tablicy prymitywów (jak int[], long[], char[], byte[], itd.)

W Javie 8 i nowszych możesz umieścić tablicę w pudełku za pomocą:

Integer[] boxedArr = Arrays.stream(arr).boxed().toArray(Integer[]::new);

Następnie przekonwertuj na zestaw za pomocą strumienia:

Stream.of(boxedArr).collect(Collectors.toSet());

Kiedyś korzystanie ze standardowych bibliotek bardzo pomaga. Spróbuj spojrzeć na Kolekcje Apache Commons . W takim przypadku Twoje problemy są po prostu przekształcane w coś takiego

String[] keys = {"blah", "blahblah"}
Set<String> myEmptySet = new HashSet<String>();
CollectionUtils.addAll(pythonKeywordSet, keys);

A oto javadoc CollectionsUtils

Użyj CollectionUtilslub ArrayUtilszstanford-postagger-3.0.jar

import static edu.stanford.nlp.util.ArrayUtils.asSet;
or 
import static edu.stanford.nlp.util.CollectionUtils.asSet;

  ...
String [] array = {"1", "q"};
Set<String> trackIds = asSet(array);

W Javie 10 :

String[] strs = {"A", "B"};
Set<String> set = Set.copyOf(Arrays.asList(strs));

Set.copyOfzwraca niemodyfikowalną Setzawierającą elementy danego Collection.

 Podane Collectionnie może być nulli nie może zawierać żadnych nullelementów.

private Map<Integer, Set<Integer>> nobreaks = new HashMap();
nobreaks.put(1, new HashSet(Arrays.asList(new int[]{2, 4, 5})));
System.out.println("expected size is 3: " +nobreaks.get(1).size());

wyjście jest

expected size is 3: 1

zmień na

nobreaks.put(1, new HashSet(Arrays.asList( 2, 4, 5 )));

wyjście jest

expected size is 3: 3

Dla każdego, kto rozwiązuje problem dla Androida:

Rozwiązanie Kotlin Collections

Gwiazdką *jest spreadoperator. Stosuje wszystkie elementy w kolekcji osobno, każdy przekazany w celu varargparametru metody. Jest to równoważne z:

val myArray = arrayOf("data", "foo")
val mySet = setOf(*myArray)

// Equivalent to
val mySet = setOf("data", "foo")

// Multiple spreads ["data", "foo", "bar", "data", "foo"]
val mySet = setOf(*myArray, "bar", *myArray)

Nieprzekazanie parametrów setOf()powoduje powstanie pustego zestawu.

Oprócz tego setOfmożesz użyć dowolnego z nich dla określonego typu skrótu:

hashSetOf()
linkedSetOf()
mutableSetOf()
sortableSetOf()

W ten sposób można jawnie zdefiniować typ elementu kolekcji.

setOf<String>()
hashSetOf<MyClass>()

new HashSet<Object>(Arrays.asList(Object[] a));

Ale myślę, że byłoby to bardziej wydajne:

final Set s = new HashSet<Object>();    
for (Object o : a) { s.add(o); }         

Set<T> b = new HashSet<>(Arrays.asList(requiredArray));