web-dev-qa-db-fra.com

Comment convertir un tableau en un ensemble dans Java

Je voudrais convertir un tableau en un ensemble en Java. Il y a des façons évidentes de le faire (c'est-à-dire avec une boucle) mais j'aimerais quelque chose d'un peu plus ordonné, quelque chose comme:

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

Des idées?

javacollectionsarraysset
660
user130076

Comme ça:

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

Dans Java 9+, si le paramètre non modifiable est correct:

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

Dans Java 10+, le paramètre de type générique peut être déduit du type de composant tableau:

var mySet = Set.of(someArray);
1154
SLaks
Set<T> mySet = new HashSet<T>();
Collections.addAll(mySet, myArray);

C'est Collections.addAll (Java.util.Collection, T ...) à partir de JDK 6.

De plus: si notre tableau est plein de primitives?

Pour JDK <8, je voudrais simplement écrire la boucle évidente for pour effectuer le bouclage et l'addition d'un ensemble en un seul passage.

Pour JDK> = 8, une option attrayante est quelque chose comme:

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

Avec Guava vous pouvez faire:

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

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]
64
max

Varargs fonctionnera aussi!

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

Java 8

Nous avons également la possibilité d’utiliser Stream. Nous pouvons obtenir le flux de différentes manières:

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

Le code source de Collectors.toSet() indique que les éléments sont ajoutés un par un à un HashSet, mais les spécifications ne garantissent pas qu'il s'agira d'un HashSet.

"Il n'y a aucune garantie sur le type, la mutabilité, la sérialisabilité ou la sécurité des threads de l'ensemble renvoyé."

Il est donc préférable d’utiliser la dernière option. Le résultat est: [A, B, C, D] [A, B, C, D] [A, B, C, D]

Ensemble immuable (Java 9)

Java 9 a introduit la méthode de fabrique statique Set.of qui renvoie un ensemble immuable pour les éléments fournis ou le tableau.

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

Vérifiez Méthodes d'usine statiques définies immuables pour plus de détails.

Ensemble immuable (Java 10)

Nous pouvons également obtenir un ensemble immuable de deux manières:

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

La méthode Collectors.toUnmodifiableList() utilise en interne Set.of introduit dans Java 9. Vérifiez également ceci réponse à moi pour plus d'informations.

25
i_am_zero

Après avoir fait Arrays.asList(array) vous pouvez exécuter Set set = new HashSet(list);

Voici un exemple de méthode, vous pouvez écrire:

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

Dans Eclipse Collections , ce qui suit fonctionnera:

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

Remarque: je suis un partisan des collections Eclipse

10
Donald Raab

Rapidement: tu peux faire:

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

et inverser

// 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()]);
6
Pierre-Olivier Pignon

J'ai écrit ce qui suit du conseil ci-dessus - volez-le ... c'est gentil!

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

Il y a déjà eu beaucoup de bonnes réponses, mais la plupart d'entre elles ne fonctionneront pas avec un tableau de primitives comme (int[], byte[], long[], char[], etc. )

Dans Java 8 et versions ultérieures, encadrez le tableau avec quelque chose comme:

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

Ensuite, un simple flux peut le convertir en set:

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

Parfois, utiliser certaines bibliothèques standard aide beaucoup. Essayez de regarder Apache Commons Collections . Dans ce cas, vos problèmes sont simplement transformés en quelque chose comme ceci

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

Et voici le CollectionsUtils javadoc

0
mnagni

En Java 10 :

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

Set.copyOf retourne un Set non modifiable contenant les éléments du Collection donné.

La Collection donnée ne doit pas être null et elle ne doit contenir aucun élément null.

0
Oleksandr Pyrohov
    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());

la sortie est

    expected size is 3: 1

changez le en

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

la sortie est

    expected size is 3: 3
0
Bruce Zu

Utilisez CollectionUtils ou ArrayUtils à partir de stanford-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);
0
Olexandra Dmytrenko