Le moyen le plus simple de transformer une collection en tableau?

Supposons que nous ayons un Collection<Foo>. Quelle est la meilleure façon (la plus courte en LoC dans le contexte actuel) de la transformer Foo[]? Toutes les bibliothèques connues sont autorisées.

UPD: (un cas de plus dans cette section; laissez des commentaires si vous pensez que cela vaut la peine de créer un autre thread pour cela): Qu'en est-il de la transformation Collection<Foo>en Bar[]where Barhas constructeur avec 1 paramètre de type Fooie public Bar(Foo foo){ ... }?

Où xest la collection:

Foo[] foos = x.toArray(new Foo[x.size()]);

Solution alternative à la question mise à jour en utilisant Java 8:

Bar[] result = foos.stream()
    .map(x -> new Bar(x))
    .toArray(size -> new Bar[size]);

Si vous l'utilisez plus d'une fois ou en boucle, vous pouvez définir une constante

public static final Foo[] FOO = new Foo[]{};

et faire la conversion comme

Foo[] foos = fooCollection.toArray(FOO);

La toArrayméthode utilise le tableau vide pour déterminer le type correct du tableau cible et crée un nouveau tableau pour vous.

Voici ma proposition de mise à jour:

Collection<Foo> foos = new ArrayList<Foo>();
Collection<Bar> temp = new ArrayList<Bar>();
for (Foo foo:foos) 
    temp.add(new Bar(foo));
Bar[] bars = temp.toArray(new Bar[]{});

Avec JDK / 11, une autre façon de convertir un Collection<Foo>en un Foo[]pourrait être d'utiliser Collection.toArray(IntFunction<T[]> generator)comme:

Foo[] foos = fooCollection.toArray(new Foo[0]); // before JDK 11
Foo[] updatedFoos = fooCollection.toArray(Foo[]::new); // after JDK 11

Comme expliqué par @Stuart sur la liste de diffusion (c'est moi qui souligne), les performances de celui-ci devraient essentiellement être les mêmes que celles de l'existant Collection.toArray(new T[0])-

Le résultat est que les implémentations qui utilisent Arrays.copyOf() sont les plus rapides, probablement parce que c'est intrinsèque .

Il peut éviter de remplir à zéro le tableau fraîchement alloué car il sait que tout le contenu du tableau sera écrasé. Cela est vrai quel que soit l'aspect de l'API publique.

La mise en œuvre de l'API dans le JDK se lit comme suit:

default <T> T[] toArray(IntFunction<T[]> generator) {
    return toArray(generator.apply(0));
}

L'implémentation par défaut appelle generator.apply(0)pour obtenir un tableau de longueur nulle, puis appelle simplement toArray(T[]). Cela passe par le Arrays.copyOf() chemin rapide, donc c'est essentiellement la même vitesse que toArray(new T[0]).

Remarque : - Simplement que l'utilisation de l'API doit être guidée avec une incompatibilité descendante lorsqu'elle est utilisée pour du code avec desnullvaleurs, par exempletoArray(null)puisque ces appels seraient maintenant ambigus en raison de l'existanttoArray(T[] a)et échoueraient à se compiler.

Si vous utilisez Guava dans votre projet, vous pouvez utiliser Iterables::toArray.

Foo[] foos = Iterables.toArray(x, Foo.class);

Pour l'original, voir la réponse doublep :

Foo[] a = x.toArray(new Foo[x.size()]);

Quant à la mise à jour:

int i = 0;
Bar[] bars = new Bar[fooCollection.size()];
for( Foo foo : fooCollection ) { // where fooCollection is Collection<Foo>
    bars[i++] = new Bar(foo);
}    

Voici la solution finale pour le cas dans la section mise à jour (avec l'aide de Google Collections):

Collections2.transform (fooCollection, new Function<Foo, Bar>() {
    public Bar apply (Foo foo) {
        return new Bar (foo);
    }
}).toArray (new Bar[fooCollection.size()]);

Mais, l'approche clé ici a été mentionnée dans la réponse du doublep (j'ai oublié la toArrayméthode).

Par exemple, vous avez la collection ArrayList avec des éléments Student class:

List stuList = new ArrayList();
Student s1 = new Student("Raju");
Student s2 = new Student("Harish");
stuList.add(s1);
stuList.add(s2);
//now you can convert this collection stuList to Array like this
Object[] stuArr = stuList.toArray();           // <----- toArray() function will convert collection to array