Bir diziyi Java'da bir kümeye dönüştürme

Bir dizi Java bir Set dönüştürmek istiyorum. Bunu yapmanın bazı belirgin yolları vardır (yani bir döngü ile) ama biraz daha temiz bir şey istiyorum, şöyle bir şey:

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

Herhangi bir fikir?

Bunun gibi:

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

Java 9 ve sonraki sürümlerinde değiştirilemez küme tamamsa:

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

Java 10+ sürümünde, genel tür parametresi diziler bileşen türünden çıkarılabilir:

var mySet = Set.of(someArray);

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

Budur Collections.addAll (java.util.Collection T ...) JDK 6 dan.

Ayrıca: dizimiz ilkellerle doluysa ne olacak?

JDK <8 için, sadece forbir geçişte sarma ve eklenti ayarlamak için bariz döngü yazacağım .

JDK> = 8 için çekici bir seçenek şuna benzer:

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

İle Guava Yapabileceğiniz:

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 da çalışacak!

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

Java 8

Bizim de kullanma seçeneğimiz var Stream. Çeşitli şekillerde akış elde edebiliriz:

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

Kaynak kodu, Collectors.toSet()öğelerin bire birer birer eklendiğini gösterir, HashSetancak şartname bunun olacağını garanti etmez HashSet.

"İade edilen Setin türü, değiştirilebilirliği, serileştirilebilirliği veya iş parçacığı güvenliği konusunda hiçbir garanti yoktur."

Bu yüzden sonraki seçeneği kullanmak daha iyidir. Çıktı: [A, B, C, D] [A, B, C, D] [A, B, C, D]

Değişmez Küme (Java 9)

Java 9 tanıtıldı Set.of , sağlanan öğeler veya dizi için değişmez kümeyi döndüren statik fabrika yöntemini .

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

Kontrol Ayrıntılar için Dayanıklı Set Statik Fabrika Yöntemlerini .

Değişmez Küme (Java 10)

Ayrıca iki şekilde değişmez bir set alabiliriz:

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

Yöntem Collectors.toUnmodifiableList()dahili Set.ofolarak Java 9'da kullanılmaya başlandı. Ayrıca daha fazla bilgi için bu cevabımı kontrol edin .

Yaptıktan sonra Arrays.asList(array) sen yürütebilirsinizSet set = new HashSet(list);

İşte örnek bir yöntem, yazabilirsiniz:

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

In Eclipse Koleksiyonları , şu işe yarar:

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

Not: Eclipse Collections için bir komisyoncuyum

Çabuk: şunları yapabilirsiniz:

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

ve tersine çevirmek

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

Yukarıdaki tavsiyeden aşağıda yazdım - çal ... güzel!

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

Orada zaten büyük yanıtlar çok olmuştur, ama bunların çoğu ilkel dizisi ile çalışmaz (gibi int[], long[], char[], byte[], vb)

Java 8 ve üstü sürümlerde diziyi şunlarla kutulayabilirsiniz:

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

Sonra akışı kullanarak kümeye dönüştürün:

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

Bazen bazı standart kütüphaneleri kullanmak çok yardımcı olur. Apache Commons Koleksiyonlarına bakmaya çalışın . Bu durumda sorunlarınız basitçe böyle bir şeye dönüşür

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

Ve burada KoleksiyonlarUtils javadoc

Kullanım CollectionUtilsveya ArrayUtilsgelenstanford-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.copyOfSetverilen öğeleri içeren değiştirilemez bir öğe döndürür Collection.

 Verilen Collectionolmamalı nullve herhangi bir nullunsur içermemelidir .

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

çıktı

expected size is 3: 1

olarak değiştir

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

çıktı

expected size is 3: 3

Android için çözen herkes için:

Kotlin Koleksiyonlar Çözümü

Yıldız işareti *olan spreadoperatör. Bir koleksiyondaki tüm öğeleri, her biri bir varargyöntem parametresine iletilmek üzere ayrı ayrı uygular . Şuna eşdeğerdir:

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)

Hiçbir parametre iletilmezse setOf()boş bir küme oluşur.

Ayrıca setOf, bunlardan herhangi birini belirli bir karma türü için de kullanabilirsiniz:

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

Koleksiyon öğesi türünü bu şekilde açıkça tanımlayabilirsiniz.

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

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

Ama bunun daha verimli olacağını düşünüyorum:

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

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