So konvertieren Sie ein Array in ein Set in Java

Ich möchte ein Array in ein Set in Java konvertieren. Es gibt einige offensichtliche Möglichkeiten, dies zu tun (dh mit einer Schleife), aber ich möchte etwas etwas ordentlicheres, etwas wie:

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

Irgendwelche Ideen?

So was:

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

Wenn in Java 9+ die nicht veränderbare Menge in Ordnung ist:

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

In Java 10+ kann der generische Typparameter aus dem Array-Komponententyp abgeleitet werden:

var mySet = Set.of(someArray);

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

Das ist Collections.addAll (java.util.Collection, T ...) aus JDK 6.

Zusätzlich: Was ist, wenn unser Array voller Grundelemente ist?

Für JDK <8 würde ich nur die offensichtliche forSchleife schreiben , um den Wrap und das Add-to-Set in einem Durchgang durchzuführen.

Für JDK> = 8 ist eine attraktive Option wie folgt:

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

Mit Guava können Sie Folgendes tun:

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 wird auch funktionieren!

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

Java 8

Wir haben die Möglichkeit, Streamauch zu verwenden. Wir können Streams auf verschiedene Arten erhalten:

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

Der Quellcode von Collectors.toSet()zeigt, dass Elemente HashSeteinzeln zu einem hinzugefügt werden , die Spezifikation jedoch nicht garantiert, dass es sich um ein Element handelt HashSet.

"Es gibt keine Garantie für den Typ, die Veränderlichkeit, die Serialisierbarkeit oder die Thread-Sicherheit des zurückgegebenen Sets."

Daher ist es besser, die spätere Option zu verwenden. Die Ausgabe ist: [A, B, C, D] [A, B, C, D] [A, B, C, D]

Unveränderliches Set (Java 9)

In Java 9 wurde die Set.ofstatische Factory-Methode eingeführt, die unveränderliche Mengen für die bereitgestellten Elemente oder das Array zurückgibt.

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

Weitere Informationen finden Sie unter Statische Factory-Methoden für unveränderliche Sets .

Unveränderliches Set (Java 10)

Wir können ein unveränderliches Set auch auf zwei Arten erhalten:

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

Die Methode verwendet Collectors.toUnmodifiableList()intern die Set.ofin Java 9 eingeführte Methode . Weitere Informationen finden Sie auch in meiner Antwort .

Nachdem Sie dies getan haben Arrays.asList(array), können Sie ausführenSet set = new HashSet(list);

Hier ist eine Beispielmethode, die Sie schreiben können:

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

In Eclipse-Sammlungen funktioniert Folgendes:

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

Hinweis: Ich bin ein Committer für Eclipse-Sammlungen

Schnell: Sie können tun:

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

und umzukehren

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

Ich habe das Folgende aus dem Rat oben geschrieben - stiehl es ... es ist schön!

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

Es hat schon viele gute Antworten, aber die meisten von ihnen werden nicht mit Array von Primitiven arbeiten (wie int[], long[], char[], byte[], etc.)

In Java 8 und höher können Sie das Array mit folgenden Elementen versehen:

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

Dann konvertieren, um mit Stream zu setzen:

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

Manchmal hilft die Verwendung einiger Standardbibliotheken sehr. Versuchen Sie, sich die Apache Commons-Sammlungen anzusehen . In diesem Fall werden Ihre Probleme einfach in so etwas umgewandelt

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

Und hier ist das CollectionsUtils javadoc

Verwenden Sie CollectionUtilsoder ArrayUtilsvonstanford-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);

In Java 10 :

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

Set.copyOfGibt eine nicht modifizierbare Datei zurück, Setdie die Elemente der angegebenen enthält Collection.

 Das Gegebene Collectiondarf nicht sein nullund darf keine nullElemente enthalten .

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

die Ausgabe ist

expected size is 3: 1

ändere es auf

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

die Ausgabe ist

expected size is 3: 3

Für alle, die nach Android suchen:

Kotlin-Sammlungslösung

Das Sternchen *ist der spreadOperator. Es wendet alle Elemente in einer Sammlung einzeln an, die jeweils an einen varargMethodenparameter übergeben werden. Es ist äquivalent zu:

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)

Das Übergeben keiner Parameter setOf()führt zu einem leeren Satz.

Darüber hinaus setOfkönnen Sie eine dieser Optionen auch für einen bestimmten Hash-Typ verwenden:

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

So definieren Sie den Sammlungselementtyp explizit.

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

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

Aber ich denke, das wäre effizienter:

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

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